import { describe, it, before } from "node:test"
import assert from "node:assert"
import { PlataGlobalRuntime } from "../libs/runtime"
import { PlataModels } from ".."

describe('PlataModels.union', () => {
    const plataPromise = (async () => {
        const g = global as any
    
        g.Plata = new PlataGlobalRuntime()
    })()

    before(async () => {
        await plataPromise
    })

    const modelTemplateEnv = new PlataModels.ModelTemplateEnv({
        test_union: [ PlataModels.Required(), PlataModels.VarChar(Infinity) ],
        ENV_enum: [ PlataModels.Enum([ 0, 1 ]) ],
        ENV_decimal: [ PlataModels.Decimal(2,2) ],
        ENV_intMin: [ PlataModels.Int(5) ],
        ENV_intMax: [ PlataModels.Int(undefined, 5) ],
        ENV_intRequired: [ PlataModels.Required(), PlataModels.Int() ],
        ENV_smallDateTime: [ PlataModels.SmallDateTime() ],
        ENV_varChar: [ PlataModels.VarChar(1) ],
    })

    const modelTemplate = new PlataModels.ModelTemplate({
        test_union: [ PlataModels.Required(), PlataModels.VarChar(Infinity) ],
        enum: [ PlataModels.Enum([ 0,1 ]) ],
        stringDateTime: [ PlataModels.StringDateTime() ],
        dateTime: [ PlataModels.DateTime() ],
        decimal: [ PlataModels.Decimal(2,2) ],
        intMin: [ PlataModels.Int(5) ],
        intMax: [ PlataModels.Int(undefined, 5) ],
        intRequired:  [ PlataModels.Required(), PlataModels.Int() ],
        smallDateTime: [ PlataModels.SmallDateTime() ],
        telefone: [ PlataModels.Telefone() ],
        telefoneDDI: [ PlataModels.TelefoneDDI() ],
        varCharMin: [ PlataModels.VarChar(1, 1) ],
        varChar:  [ PlataModels.VarChar(1) ],
    } as const, {})

    const modelUnion = new PlataModels.ModelTemplateUnion({ key: 'key' }, {
        modelTemplate,
        modelTemplateEnv,
    })

    modelUnion.addFilter(x => {
        x.test_union = x.test_union === true ? '1' : null

        return x
    })

    const getTemplateOkay = () => ({
        test_union: true,
        key: 'modelTemplate',
        enum: 0,
        stringDateTime: '2022-12-04T02:06:22',
        dateTime: new Date(),
        decimal: 99.99,
        intMin: 5,
        intMax: 5,
        intRequired: 1,
        smallDateTime: '2022-12-04',
        telefone: '99-999999999',
        telefoneDDI: '+055 99-999999999',
        varCharMin: '1',
        varChar: '1',
    })

    const getTemplateNotOkay = () => ({
        key: 'modelTemplate',
        test_union: false,
        enum: 2,
        stringDateTime: '',
        dateTime: '',
        decimal: 5.666666666666,
        intMin: 1,
        intMax: 6,
        intRequired: null,
        smallDateTime: '',
        telefone: '',
        telefoneDDI: '',
        varCharMin: '',
        varChar: '11',
    }) as any // Forced just for test

    const getEnvOkay = () => ({
        key: 'modelTemplateEnv',
        test_union: true,
        ENV_enum: `${0}`,
        ENV_decimal: `${22.22}`,
        ENV_intMin: `${5}`,
        ENV_intMax: `${5}`,
        ENV_intRequired: `${6}`,
        ENV_smallDateTime: '2022-12-04',
        ENV_varChar: '1',
    })

    const getEnvNotOkay = () => ({
        key: 'modelTemplateEnv',
        test_union: false,
        ENV_enum: `${2}`,
        ENV_decimal: `${222.222}`,
        ENV_intMin: `${4}`,
        ENV_intMax: `${6}`,
        ENV_smallDateTime: '2022-12--04',
        ENV_varChar: '12',
    })

    it('Validations Env (Okay)', async () => {
        const okayObj = getEnvOkay()

        const value = await modelUnion.validate(okayObj)

        assert.strictEqual(value.errors, undefined)

        const type: { key: 'modelTemplateEnv' | 'modelTemplate'} = value.value

        assert.deepEqual(value.value, okayObj)
    })

    it('Validations Template (Okay)', async () => {
        const okayObj = getTemplateOkay()

        const value = await modelUnion.validate(okayObj)

        assert.strictEqual(value.errors, undefined)

        const type: { key: 'modelTemplateEnv' | 'modelTemplate'} = value.value

        assert.deepEqual(value.value, okayObj)
    })

    it('Validations Env (Not Okay)', async () => {
        const notOkayObj = getEnvNotOkay()

        const value = await modelUnion.validate(notOkayObj)

        assert.notStrictEqual(value.errors, undefined)
        assert.strictEqual(
            value.errors?.length,
            Object.keys(modelTemplateEnv.template).length, 
            value.errors?.map(e => `${e.errorID} - ${e.msg}`).join('\n')
        )
    })

    it('Validations Template (Not Okay)', async () => {
        const notOkayObj = getTemplateNotOkay()

        const value = await modelUnion.validate(notOkayObj)

        assert.notStrictEqual(value.errors, undefined)
        assert.strictEqual(
            value.errors?.length,
            Object.keys(modelTemplate.template).length, 
            value.errors?.map(e => `${e.errorID} - ${e.msg}`).join('\n')
        )
    })
})