package reading.models

trait FilterFactory[T] {
  def create(in: T): Filter
}

object FilterFactory {
  implicit object PeriodFilter extends FilterFactory[Period] {
    def create(period: Period): Filter =
      new Filter {
        def filter(book: Book): Boolean = book.period == Some(period)
        val kind: FilterKind = FilterKind.Period
        val nonFormattedName: String = period.toString()
        val name: String = period.prettyPrint()
      }
  }

  implicit object GroupedThemeFilter extends FilterFactory[GroupedTheme] {
    def create(groupedTheme: GroupedTheme): Filter =
      new Filter {
        def filter(book: Book): Boolean = book.themes.map(GroupedTheme.from).contains(groupedTheme)
        val kind: FilterKind = FilterKind.GroupedTheme
        val nonFormattedName: String = groupedTheme.toString()
        val name: String = groupedTheme.prettyPrint()
      }
  }

  implicit object ThemeFilter extends FilterFactory[Theme] {
    def create(theme: Theme): Filter =
      new Filter {
        def filter(book: Book): Boolean = book.themes.contains(theme)
        val kind: FilterKind = FilterKind.Theme
        val nonFormattedName: String = theme.toString()
        val name: String = theme.prettyPrint()
      }
  }

  implicit object GenreFilter extends FilterFactory[Genre] {
    def create(genre: Genre): Filter =
      new Filter {
        def filter(book: Book): Boolean = book.genres.contains(genre)
        val kind: FilterKind = FilterKind.Genre
        val nonFormattedName: String = genre.toString()
        val name: String = genre.prettyPrint()
      }
  }

  implicit object ProgramFilter extends FilterFactory[Program] {
    def create(program: Program): Filter =
      new Filter {
        def filter(book: Book): Boolean = book.programs.contains(program)
        val kind: FilterKind = FilterKind.Program
        val nonFormattedName: String = program.toString()
        val name: String = program.prettyPrint()
      }
  }

  implicit object GradeFilter extends FilterFactory[Grade] {
    def create(grade: Grade): Filter =
      new Filter {
        def filter(book: Book): Boolean = book.programs.map(Grade.from).contains(grade)
        val kind: FilterKind = FilterKind.Grade
        val nonFormattedName: String = grade.toString()
        val name: String = grade.prettyPrint()
      }
  }

  implicit object LevelFilter extends FilterFactory[Level] {
    def create(level: Level): Filter =
      new Filter {
        def filter(book: Book): Boolean = book.level == level
        val kind: FilterKind = FilterKind.Level
        val nonFormattedName: String = level.toString()
        val name: String = level.prettyPrint()
      }
  }
}