import { getNewFieldValue, safeParseField } from "../src/types"
import { getNewField } from "../src/templateApi/fields"
import { isDefined } from "../src/common"

const getField = type => {
  const field = getNewField(type)
  return field
}

const nothingReference = { key: "" }
const nothingFile = { relativePath: "", size: 0 }

describe("types > getNew", () => {
  const defaultAlwaysNull = type => () => {
    const field = getField(type)
    field.getInitialValue = "default"
    const value = getNewFieldValue(field)
    expect(value).toBe(null)
  }

  it(
    "bool should return null when fields getInitialValue is 'default'",
    defaultAlwaysNull("bool")
  )

  it(
    "string should return null when fields getInitialValue is 'default'",
    defaultAlwaysNull("string")
  )

  it(
    "number should return null when fields getInitialValue is 'default'",
    defaultAlwaysNull("number")
  )

  it(
    "datetime should return null when fields getInitialValue is 'default'",
    defaultAlwaysNull("datetime")
  )

  it("reference should return {key:''} when fields getInitialValue is 'default'", () => {
    const field = getField("reference")
    field.getInitialValue = "default"
    const value = getNewFieldValue(field)
    expect(value).toEqual(nothingReference)
  })

  it("file should return {relativePath:'', size:0} when fields getInitialValue is 'default'", () => {
    const field = getField("file")
    field.getInitialValue = "default"
    const value = getNewFieldValue(field)
    expect(value).toEqual(nothingFile)
  })

  it("array should return empty array when field getInitialValue is 'default'", () => {
    const field = getField("array<string>")
    field.getInitialValue = "default"
    const value = getNewFieldValue(field)
    expect(value).toEqual([])
  })

  it("datetime should return Now when getInitialValue is 'now'", () => {
    const field = getField("datetime")
    field.getInitialValue = "now"
    const before = new Date()
    const value = getNewFieldValue(field)
    const after = new Date()
    expect(value >= before && value <= after).toBeTruthy()
  })

  const test_getNewFieldValue = (type, val, expected) => () => {
    const field = getField(type)
    field.getInitialValue = val
    const value = getNewFieldValue(field)
    expect(value).toEqual(expected)
  }

  it("bool should parse value in getInitialValue if function not recognised", () => {
    test_getNewFieldValue("bool", "true", true)()
    test_getNewFieldValue("bool", "on", true)()
    test_getNewFieldValue("bool", "1", true)()
    test_getNewFieldValue("bool", "yes", true)()
    test_getNewFieldValue("bool", "false", false)()
    test_getNewFieldValue("bool", "off", false)()
    test_getNewFieldValue("bool", "0", false)()
    test_getNewFieldValue("bool", "no", false)()
  })

  it("bool should return null if function not recognised and value cannot be parsed", () => {
    test_getNewFieldValue("bool", "blah", null)()
    test_getNewFieldValue("bool", 111, null)()
  })

  it("number should parse value in getInitialValue if function not recognised", () => {
    test_getNewFieldValue("number", "1", 1)()
    test_getNewFieldValue("number", "45", 45)()
    test_getNewFieldValue("number", "4.11", 4.11)()
  })

  it("number should return null if function not recognised and value cannot be parsed", () => {
    test_getNewFieldValue("number", "blah", null)()
    test_getNewFieldValue("number", true, null)()
  })

  it("string should parse value in getInitialValue if function not recognised", () => {
    test_getNewFieldValue("string", "hello there", "hello there")()
    test_getNewFieldValue("string", 45, "45")()
    test_getNewFieldValue("string", true, "true")()
  })

  it("array should return empty array when function not recognised", () => {
    test_getNewFieldValue("array<string>", "blah", [])()
    test_getNewFieldValue("array<bool>", true, [])()
    test_getNewFieldValue("array<number>", 1, [])()
    test_getNewFieldValue("array<datetime>", "", [])()
    test_getNewFieldValue("array<reference>", "", [])()
    test_getNewFieldValue("array<file>", "", [])()
  })

  it("reference should {key:''} when function not recognised", () => {
    test_getNewFieldValue("reference", "blah", nothingReference)()
  })

  it("file should return {relativePath:'',size:0} when function not recognised", () => {
    test_getNewFieldValue("file", "blah", nothingFile)()
  })
})

describe("types > getSafeFieldValue", () => {
  const test_getSafeFieldValue = (type, member, value, expectedParse) => () => {
    const field = getField(type)
    field.getDefaultValue = "default"
    field.name = member
    const record = {}
    if (isDefined(value)) record[member] = value
    const parsedvalue = safeParseField(field, record)
    expect(parsedvalue).toEqual(expectedParse)
  }

  it(
    "should get default field value when member is undefined on record",
    test_getSafeFieldValue("string", "forename", undefined, null)
  )

  it("should return null as null (except array and reference)", () => {
    test_getSafeFieldValue("string", "forename", null, null)()
    test_getSafeFieldValue("bool", "isalive", null, null)()
    test_getSafeFieldValue("datetime", "created", null, null)()
    test_getSafeFieldValue("number", "age", null, null)()
    test_getSafeFieldValue("array<string>", "tags", null, [])()
    test_getSafeFieldValue("reference", "moretags", null, nothingReference)()
    test_getSafeFieldValue("file", "moretags", null, nothingFile)()
  })

  it("bool should parse a defined set of true/false aliases", () => {
    test_getSafeFieldValue("bool", "isalive", true, true)()
    test_getSafeFieldValue("bool", "isalive", "true", true)()
    test_getSafeFieldValue("bool", "isalive", "on", true)()
    test_getSafeFieldValue("bool", "isalive", "1", true)()
    test_getSafeFieldValue("bool", "isalive", "yes", true)()
    test_getSafeFieldValue("bool", "isalive", false, false)()
    test_getSafeFieldValue("bool", "isalive", "false", false)()
    test_getSafeFieldValue("bool", "isalive", "off", false)()
    test_getSafeFieldValue("bool", "isalive", "0", false)()
    test_getSafeFieldValue("bool", "isalive", "no", false)()
  })

  it(
    "bool should parse invalid values as null",
    test_getSafeFieldValue("bool", "isalive", "blah", null)
  )

  it("number should parse numbers and strings that are numbers", () => {
    test_getSafeFieldValue("number", "age", 204, 204)()
    test_getSafeFieldValue("number", "age", "1", 1)()
    test_getSafeFieldValue("number", "age", "45", 45)()
    test_getSafeFieldValue("number", "age", "4.11", 4.11)()
  })

  it(
    "number should parse invalid values as null",
    test_getSafeFieldValue("number", "age", "blah", null)
  )

  it(
    "string should parse strings",
    test_getSafeFieldValue("string", "forename", "bob", "bob")
  )

  it("string should parse any other basic type", () => {
    test_getSafeFieldValue("string", "forename", true, "true")()
    test_getSafeFieldValue("string", "forename", 1, "1")()
  })

  it("date should parse dates in various precisions", () => {
    // dont forget that JS Date's month is zero based
    test_getSafeFieldValue(
      "datetime",
      "createddate",
      "2018-02-14",
      new Date(2018, 1, 14)
    )()
    test_getSafeFieldValue(
      "datetime",
      "createddate",
      "2018-2-14",
      new Date(2018, 1, 14)
    )()
    test_getSafeFieldValue(
      "datetime",
      "createddate",
      "2018-02-14 11:00:00.000",
      new Date(2018, 1, 14, 11)
    )()
    test_getSafeFieldValue(
      "datetime",
      "createddate",
      "2018-02-14 11:30",
      new Date(2018, 1, 14, 11, 30)
    )()
  })

  it("date should parse invalid dates as null", () => {
    // dont forget that JS Date's month is zero based
    test_getSafeFieldValue("datetime", "createddate", "2018-13-14", null)()
    test_getSafeFieldValue("datetime", "createddate", "2018-2-33", null)()
    test_getSafeFieldValue("datetime", "createddate", "bla", null)()
  })

  it("array should parse array", () => {
    test_getSafeFieldValue(
      "array<string>",
      "tags",
      ["bob", "the", "dog"],
      ["bob", "the", "dog"]
    )()
    test_getSafeFieldValue(
      "array<bool>",
      "tags",
      [true, false],
      [true, false]
    )()
    test_getSafeFieldValue(
      "array<number>",
      "tags",
      [1, 2, 3, 4],
      [1, 2, 3, 4]
    )()
    test_getSafeFieldValue(
      "array<reference>",
      "tags",
      [{ key: "/customer/1234", value: "bob" }],
      [{ key: "/customer/1234", value: "bob" }]
    )()
  })

  it("array should convert the generic's child type", () => {
    test_getSafeFieldValue("array<string>", "tags", [1, true], ["1", "true"])()
    test_getSafeFieldValue(
      "array<bool>",
      "tags",
      ["yes", "true", "no", "false", true, false],
      [true, true, false, false, true, false]
    )()
    test_getSafeFieldValue("array<number>", "tags", ["1", 23], [1, 23])()
  })

  it("reference should parse reference", () => {
    test_getSafeFieldValue(
      "reference",
      "customer",
      { key: "/customer/1234", value: "bob" },
      { key: "/customer/1234", value: "bob" }
    )()
  })

  it("reference should parse reference", () => {
    test_getSafeFieldValue(
      "file",
      "profilepic",
      { relativePath: "path/to/pic.jpg", size: 120 },
      { relativePath: "path/to/pic.jpg", size: 120 }
    )()
  })
})