package gs.predicate.v0.string

import gs.datagen.v0.Gen
import gs.datagen.v0.generators.Range
import java.time.LocalDate
import munit.FunSuite

class StringComparisonTests extends FunSuite:
  import StringComparisonTests.*

  test("should support True") {
    val jc = StringComparison.True
    assert(jc.compare(""))
  }

  test("should support False") {
    val jc = StringComparison.False
    assert(!jc.compare(""))
  }

  test("should support And") {
    val jc1 = StringComparison.And(
      List(StringComparison.True, StringComparison.True, StringComparison.False)
    )
    val jc2 =
      StringComparison.And(List(StringComparison.True, StringComparison.True))
    val jc3 = StringComparison.And(List())
    val str = ""
    assert(!jc1.compare(str))
    assert(jc2.compare(str))
    assert(jc3.compare(str))
  }

  test("should support Or") {
    val jc1 = StringComparison.Or(
      List(StringComparison.True, StringComparison.True, StringComparison.False)
    )
    val jc2 =
      StringComparison.Or(List(StringComparison.False, StringComparison.False))
    val jc3 = StringComparison.Or(List())
    val str = ""
    assert(jc1.compare(str))
    assert(!jc2.compare(str))
    assert(!jc3.compare(str))
  }

  test("should support Eq") {
    val value = strGen.gen()
    val jc    = StringComparison.Eq(value)
    assert(jc.compare(value))
    assert(!jc.compare(value + value))
  }

  test("should support Neq") {
    val value = strGen.gen()
    val jc    = StringComparison.Neq(value)
    assert(!jc.compare(value))
    assert(jc.compare(value + value))
  }

  test("should support StringContains") {
    val str    = strGen.gen()
    val substr = str.substring(3, 7)
    val jc1    = StringComparison.StringContains(substr)
    val jc2    = StringComparison.StringContains(str)
    val jc3    = StringComparison.StringContains(longStrGen.gen())
    assert(jc1.compare(str))
    assert(jc2.compare(str))
    assert(!jc3.compare(str))
  }

  test("should support StringPrefix") {
    val str    = strGen.gen()
    val substr = str.take(4)
    val jc1    = StringComparison.StringPrefix(substr)
    val jc2    = StringComparison.StringPrefix(str)
    val jc3    = StringComparison.StringPrefix(longStrGen.gen())
    assert(jc1.compare(str))
    assert(jc2.compare(str))
    assert(!jc3.compare(str))
  }

  test("should support StringSuffix") {
    val str    = strGen.gen()
    val substr = str.takeRight(4)
    val jc1    = StringComparison.StringSuffix(substr)
    val jc2    = StringComparison.StringSuffix(str)
    val jc3    = StringComparison.StringSuffix(longStrGen.gen())
    assert(jc1.compare(str))
    assert(jc2.compare(str))
    assert(!jc3.compare(str))
  }

  test("should support IntLessThan") {
    val int    = intGen.gen()
    val target = 101
    val jc1    = StringComparison.IntLessThan(target)
    val jc3    = StringComparison.IntLessThan(-1)
    assert(jc1.compare(int.toString()))
    assert(!jc3.compare(int.toString()))
  }

  test("should support IntLessThanOrEqualTo") {
    val int    = intGen.gen()
    val target = 101
    val jc1    = StringComparison.IntLessThanOrEqualTo(target)
    val jc2    = StringComparison.IntLessThanOrEqualTo(int)
    val jc3    = StringComparison.IntLessThan(-1)
    assert(jc1.compare(int.toString()))
    assert(jc2.compare(int.toString()))
    assert(!jc3.compare(int.toString()))
  }

  test("should support IntGreaterThan") {
    val int    = intGen.gen()
    val target = -1
    val jc1    = StringComparison.IntGreaterThan(target)
    val jc3    = StringComparison.IntGreaterThan(101)
    assert(jc1.compare(int.toString()))
    assert(!jc3.compare(int.toString()))
  }

  test("should support IntGreaterThanOrEqualTo") {
    val int    = intGen.gen()
    val target = -1
    val jc1    = StringComparison.IntGreaterThanOrEqualTo(target)
    val jc2    = StringComparison.IntGreaterThanOrEqualTo(int)
    val jc3    = StringComparison.IntGreaterThan(101)
    assert(jc1.compare(int.toString()))
    assert(jc2.compare(int.toString()))
    assert(!jc3.compare(int.toString()))
  }

  test("should support IntBetweenInclusive") {
    val int   = intGen.gen()
    val lower = 0
    val upper = 100
    val jc1   = StringComparison.IntBetweenInclusive(lower, upper)
    val jc2   = StringComparison.IntBetweenInclusive(int, int)
    val jc3   = StringComparison.IntBetweenInclusive(1000, 10000)
    assert(jc1.compare(int.toString()))
    assert(jc2.compare(int.toString()))
    assert(!jc3.compare(int.toString()))
  }

  test("should support IntBetweenExclusive") {
    val int   = intGen.gen()
    val lower = -1
    val upper = 101
    val jc1   = StringComparison.IntBetweenExclusive(lower, upper)
    val jc2   = StringComparison.IntBetweenExclusive(int, int)
    val jc3   = StringComparison.IntBetweenExclusive(1000, 10000)
    assert(jc1.compare(int.toString()))
    assert(!jc2.compare(int.toString()))
    assert(!jc3.compare(int.toString()))
  }

  test("should support DateEq") {
    val date   = dateGen.gen()
    val target = date
    val jc1    = StringComparison.DateEq(target)
    val jc2    = StringComparison.DateEq(target.plusDays(1L))
    assert(jc1.compare(date.toString()))
    assert(!jc2.compare(date.toString()))
  }

  test("should support DateBefore") {
    val date   = dateGen.gen()
    val target = date.plusDays(1L)
    val jc1    = StringComparison.DateBefore(target)
    val jc2    = StringComparison.DateBefore(date)
    assert(jc1.compare(date.toString()))
    assert(!jc2.compare(date.toString()))
  }

  test("should support DateAfter") {
    val date   = dateGen.gen()
    val target = date.minusDays(1L)
    val jc1    = StringComparison.DateAfter(target)
    val jc2    = StringComparison.DateAfter(date)
    assert(jc1.compare(date.toString()))
    assert(!jc2.compare(date.toString()))
  }

  test("should support DateBetweenInclusive") {
    val date  = dateGen.gen()
    val lower = date.minusDays(1L)
    val upper = date.plusDays(1L)
    val jc1   = StringComparison.DateBetweenInclusive(lower, upper)
    val jc2   = StringComparison.DateBetweenInclusive(date, date)
    val jc3   = StringComparison.DateBetweenInclusive(
      date.plusDays(1L),
      date.plusDays(1000L)
    )
    assert(jc1.compare(date.toString()))
    assert(jc2.compare(date.toString()))
    assert(!jc3.compare(date.toString()))
  }

  test("should support DateBetweenExclusive") {
    val date  = dateGen.gen()
    val lower = date.minusDays(1L)
    val upper = date.plusDays(1L)
    val jc1   = StringComparison.DateBetweenExclusive(lower, upper)
    val jc2   = StringComparison.DateBetweenExclusive(date, date)
    val jc3   = StringComparison.DateBetweenExclusive(
      date.plusDays(1L),
      date.plusDays(1000L)
    )
    assert(jc1.compare(date.toString()))
    assert(!jc2.compare(date.toString()))
    assert(!jc3.compare(date.toString()))
  }

object StringComparisonTests:

  val keyGen: Gen[String]     = Gen.string.alphaNumeric(Range.between(8, 16))
  val strGen: Gen[String]     = Gen.string.alphaNumeric(Range.between(8, 16))
  val longStrGen: Gen[String] = Gen.string.alphaNumeric(Range.fixed(32))
  val intGen: Gen[Int]        = Gen.integer.inRange(0, 100)
  val dateGen: Gen[LocalDate] = Gen.date.aroundToday(Range.between(1, 3))

end StringComparisonTests