package xyz.driver.core

import org.scalatest.{Assertions, FlatSpec, Matchers}

import scala.collection.immutable.IndexedSeq

class GeneratorsTest extends FlatSpec with Matchers with Assertions {
  import generators._

  "Generators" should "be able to generate com.drivergrp.core.Id identifiers" in {

    val generatedId1 = nextId[String]()
    val generatedId2 = nextId[String]()
    val generatedId3 = nextId[Long]()

    generatedId1.length should be >= 0
    generatedId2.length should be >= 0
    generatedId3.length should be >= 0
    generatedId1 should not be generatedId2
    generatedId2 should !==(generatedId3)
  }

  it should "be able to generate com.drivergrp.core.Id identifiers with max value" in {

    val generatedLimitedId1 = nextId[String](5)
    val generatedLimitedId2 = nextId[String](4)
    val generatedLimitedId3 = nextId[Long](3)

    generatedLimitedId1.length should be >= 0
    generatedLimitedId1.length should be < 6
    generatedLimitedId2.length should be >= 0
    generatedLimitedId2.length should be < 5
    generatedLimitedId3.length should be >= 0
    generatedLimitedId3.length should be < 4
    generatedLimitedId1 should not be generatedLimitedId2
    generatedLimitedId2 should !==(generatedLimitedId3)
  }

  it should "be able to generate com.drivergrp.core.Name names" in {

    Seq.fill(10)(nextName[String]()).distinct.size should be > 1
    nextName[String]().value.length should be >= 0

    val fixedLengthName = nextName[String](10)
    fixedLengthName.length should be <= 10
    assert(!fixedLengthName.value.exists(_.isControl))
  }

  it should "be able to generate com.drivergrp.core.NonEmptyName with non empty strings" in {

    assert(nextNonEmptyName[String]().value.value.nonEmpty)
  }

  it should "be able to generate proper UUIDs" in {

    nextUuid() should not be nextUuid()
    nextUuid().toString.length should be(36)
  }

  it should "be able to generate new Revisions" in {

    nextRevision[String]() should not be nextRevision[String]()
    nextRevision[String]().id.length should be > 0
  }

  it should "be able to generate strings" in {

    nextString() should not be nextString()
    nextString().length should be >= 0

    val fixedLengthString = nextString(20)
    fixedLengthString.length should be <= 20
    assert(!fixedLengthString.exists(_.isControl))
  }

  it should "be able to generate strings non-empty strings whic are non empty" in {

    assert(nextNonEmptyString().value.nonEmpty)
  }

  it should "be able to generate options which are sometimes have values and sometimes not" in {

    val generatedOption = nextOption("2")

    generatedOption should not contain "1"
    assert(generatedOption === Some("2") || generatedOption === None)
  }

  it should "be able to generate a pair of two generated values" in {

    val constantPair = nextPair("foo", 1L)
    constantPair._1 should be("foo")
    constantPair._2 should be(1L)

    val generatedPair = nextPair(nextId[Int](), nextName[Int]())

    generatedPair._1.length should be > 0
    generatedPair._2.length should be > 0

    nextPair(nextId[Int](), nextName[Int]()) should not be
      nextPair(nextId[Int](), nextName[Int]())
  }

  it should "be able to generate a triad of two generated values" in {

    val constantTriad = nextTriad("foo", "bar", 1L)
    constantTriad._1 should be("foo")
    constantTriad._2 should be("bar")
    constantTriad._3 should be(1L)

    val generatedTriad = nextTriad(nextId[Int](), nextName[Int](), nextBigDecimal())

    generatedTriad._1.length should be > 0
    generatedTriad._2.length should be > 0
    generatedTriad._3 should be >= BigDecimal(0.00)

    nextTriad(nextId[Int](), nextName[Int](), nextBigDecimal()) should not be
      nextTriad(nextId[Int](), nextName[Int](), nextBigDecimal())
  }

  it should "be able to generate a time value" in {

    val generatedTime = nextTime()
    val currentTime   = System.currentTimeMillis()

    generatedTime.millis should be >= 0L
    generatedTime.millis should be <= currentTime
  }

  it should "be able to generate a time range value" in {

    val generatedTimeRange = nextTimeRange()
    val currentTime        = System.currentTimeMillis()

    generatedTimeRange.start.millis should be >= 0L
    generatedTimeRange.start.millis should be <= currentTime
    generatedTimeRange.end.millis should be >= 0L
    generatedTimeRange.end.millis should be <= currentTime
    generatedTimeRange.start.millis should be <= generatedTimeRange.end.millis
  }

  it should "be able to generate a BigDecimal value" in {

    val defaultGeneratedBigDecimal = nextBigDecimal()

    defaultGeneratedBigDecimal should be >= BigDecimal(0.00)
    defaultGeneratedBigDecimal should be <= BigDecimal(1000000.00)
    defaultGeneratedBigDecimal.precision should be(2)

    val unitIntervalBigDecimal = nextBigDecimal(1.00, 8)

    unitIntervalBigDecimal should be >= BigDecimal(0.00)
    unitIntervalBigDecimal should be <= BigDecimal(1.00)
    unitIntervalBigDecimal.precision should be(8)
  }

  it should "be able to generate a specific value from a set of values" in {

    val possibleOptions = Set(1, 3, 5, 123, 0, 9)

    val pick1 = generators.oneOf(possibleOptions)
    val pick2 = generators.oneOf(possibleOptions)
    val pick3 = generators.oneOf(possibleOptions)

    possibleOptions should contain(pick1)
    possibleOptions should contain(pick2)
    possibleOptions should contain(pick3)

    val pick4 = generators.oneOf(1, 3, 5, 123, 0, 9)
    val pick5 = generators.oneOf(1, 3, 5, 123, 0, 9)
    val pick6 = generators.oneOf(1, 3, 5, 123, 0, 9)

    possibleOptions should contain(pick4)
    possibleOptions should contain(pick5)
    possibleOptions should contain(pick6)

    Set(pick1, pick2, pick3, pick4, pick5, pick6).size should be >= 1
  }

  it should "be able to generate a specific value from an enumeratum enum" in {

    import enumeratum._
    sealed trait TestEnumValue extends EnumEntry
    object TestEnum extends Enum[TestEnumValue] {
      case object Value1 extends TestEnumValue
      case object Value2 extends TestEnumValue
      case object Value3 extends TestEnumValue
      case object Value4 extends TestEnumValue
      val values: IndexedSeq[TestEnumValue] = findValues
    }

    val picks = (1 to 100).map(_ => generators.oneOf(TestEnum))

    TestEnum.values should contain allElementsOf picks
    picks.toSet.size should be >= 1
  }

  it should "be able to generate array with values generated by generators" in {

    val arrayOfTimes = arrayOf(nextTime(), 16)
    arrayOfTimes.length should be <= 16

    val arrayOfBigDecimals = arrayOf(nextBigDecimal(), 8)
    arrayOfBigDecimals.length should be <= 8
  }

  it should "be able to generate seq with values generated by generators" in {

    val seqOfTimes = seqOf(nextTime(), 16)
    seqOfTimes.size should be <= 16

    val seqOfBigDecimals = seqOf(nextBigDecimal(), 8)
    seqOfBigDecimals.size should be <= 8
  }

  it should "be able to generate vector with values generated by generators" in {

    val vectorOfTimes = vectorOf(nextTime(), 16)
    vectorOfTimes.size should be <= 16

    val vectorOfStrings = seqOf(nextString(), 8)
    vectorOfStrings.size should be <= 8
  }

  it should "be able to generate list with values generated by generators" in {

    val listOfTimes = listOf(nextTime(), 16)
    listOfTimes.size should be <= 16

    val listOfBigDecimals = seqOf(nextBigDecimal(), 8)
    listOfBigDecimals.size should be <= 8
  }

  it should "be able to generate set with values generated by generators" in {

    val setOfTimes = vectorOf(nextTime(), 16)
    setOfTimes.size should be <= 16

    val setOfBigDecimals = seqOf(nextBigDecimal(), 8)
    setOfBigDecimals.size should be <= 8
  }

  it should "be able to generate maps with keys and values generated by generators" in {

    val generatedConstantMap = mapOf("key", 123, 10)
    generatedConstantMap.size should be <= 1
    assert(generatedConstantMap.keys.forall(_ == "key"))
    assert(generatedConstantMap.values.forall(_ == 123))

    val generatedMap = mapOf(nextString(10), nextBigDecimal(), 10)
    assert(generatedMap.keys.forall(_.length <= 10))
    assert(generatedMap.values.forall(_ >= BigDecimal(0.00)))
  }

  it should "compose deeply" in {

    val generatedNestedMap = mapOf(nextString(10), nextPair(nextBigDecimal(), nextOption(123)), 10)

    generatedNestedMap.size should be <= 10
    generatedNestedMap.keySet.size should be <= 10
    generatedNestedMap.values.size should be <= 10
    assert(generatedNestedMap.values.forall(value => !value._2.exists(_ != 123)))
  }
}