import { readFileSync } from 'node:fs'
import { test as base, expect } from 'vitest'
import LoreML, { LoreMLOptions } from './index'

const testDocument = readFileSync('test.xml', 'utf-8')


class TestParser extends LoreML {
    constructor(opts?: LoreMLOptions) {
        super(opts)

    }

    public act() {
        return
    }
}

interface TestFixture {
    parser: TestParser,
}


const test = base.extend<TestFixture>({
    parser: new TestParser(),
})

test('It should be initialized.', ({ parser }) => {
    expect(parser).toBeDefined()
})

test('It should parse the test document.', async ({ parser }) => {
    const result = await parser.parse(testDocument)
    expect(result).toBeDefined()
    console.log(result)
})

test('It should parse <Document> with default root attributes.', async ({ parser }) => {
    const doc = `<Root>
        <Document>
            <Text>
                This is a test
            </Text>
        </Document>
    </Root>`
    const result = await parser.parse(doc)
    expect(result.trim()).toBe('This is a test')
})

test('It should honor a zero seed.', async () => {
    const doc = `<Root seed="0">
        <Document>
            <Text>
                <Sentence />
            </Text>
        </Document>
    </Root>`

    const first = new TestParser()
    const second = new TestParser()

    const [firstResult, secondResult] = await Promise.all([
        first.parse(doc),
        second.parse(doc),
    ])

    expect(firstResult.trim()).toBe(secondResult.trim())
})

test('It should parse <Document> with the debug header.', async ({ parser }) => {
    const doc = `<Root debug="true">
        <Document>
            <Text></Text>
        </Document>
    </Root>`
    const result = await parser.parse(doc)
    expect(result.trim()).toMatch(/version: \d+\.\d+\.\d+ \| seed: -*\d+ \| locale: en/)
})

test('It should parse <Document> with spanish localization.', async ({ parser }) => {
    const doc = `<Root seed="1" locale="es">
        <Person ref="es_test"/>
        <Document>
            <Text>
                <UsePerson ref="es_test">
                    <FirstName/> <LastName/>
                </UsePerson>
            </Text>
        </Document>
    </Root>`
    const result = await parser.parse(doc)
    expect(result.trim()).toBe('Manuel Molina Betancourt')
})

test('It should parse <Document> with german localization.', async ({ parser }) => {
    const doc = `<Root seed="1" locale="de">
        <Person ref="es_test"/>
        <Document>
            <Text>
                <UsePerson ref="es_test">
                    <FirstName/> <LastName/>
                </UsePerson>
            </Text>
        </Document>
    </Root>`
    const result = await parser.parse(doc)
    expect(result.trim()).toBe('Cedric Schumacher')
})

test('It should parse <Document> with italian localization.', async ({ parser }) => {
    const doc = `<Root seed="1" locale="it">
        <Person ref="es_test"/>
        <Document>
            <Text>
                <UsePerson ref="es_test">
                    <FirstName/> <LastName/>
                </UsePerson>
            </Text>
        </Document>
    </Root>`
    const result = await parser.parse(doc)
    expect(result.trim()).toBe('Romolo Di Giovanni')
})

test('It should parse <Document> with french localization.', async ({ parser }) => {
    const doc = `<Root seed="1" locale="fr">
        <Person ref="es_test"/>
        <Document>
            <Text>
                <UsePerson ref="es_test">
                    <FirstName/> <LastName/>
                </UsePerson>
            </Text>
        </Document>
    </Root>`
    const result = await parser.parse(doc)
    expect(result.trim()).toBe('Hildebert Cousin')
})


test('It should parse <Text /> with default attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text>
                This is a test
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toBe('This is a test')
})


test('It should parse <Text /> with nested <Text /> and no attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text>
                <Text>This is a test</Text>
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toBe('This is a test')
})

test('It should parse <Text /> with repeat attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text repeat="2">
                This is a test
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toBe('This is a test\n\n\nThis is a test')
})

test('It should parse <Text /> with pick attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text pick="2">
                <Text>1. This is a test</Text>
                <Text>2. This is a test</Text>
                <Text>3. This is a test</Text>
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result).toBe('1. This is a test\n2. This is a test\n')
})

test('It should clamp pick to the available children.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text pick="5">
                <Text>1. This is a test</Text>
                <Text>2. This is a test</Text>
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result).toContain('1. This is a test')
    expect(result).toContain('2. This is a test')
})

test('It should not crash when a referenced person is missing.', async ({ parser }) => {
    const doc = `<Root>
        <Document>
            <Text>
                Before<UsePerson ref="missing"><FullName/></UsePerson>After
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result).toBeTypeOf('string')
})

test('It should parse <UniformInt /> with default attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text>
                <UniformInt />
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toBe('0')
})

test('It should parse <UniformFloat /> with default attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text>
                <UniformFloat />
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toBe('8.92')
})

test('It should parse <Sentence /> with default attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text>
                <Sentence />
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toBe('Suppellex a cognatus arca aliquam audentia.')
})

test('It should parse <Paragraph /> with default attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text>
                <Paragraph />
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    const expected = 'A cognatus arca aliquam audentia coniuratio crux fugit. Stillicidium bardus utrimque acsi spargo cur. Aqua avaritia thesaurus volo combibo stultus utor. Ago adflicto assentator utrimque altus curiositas vita expedita stultus comedo. Trucido accusamus tandem voveo tamisium cicuta testimonium amet. Ver claudeo civis aperio accusantium spoliatio.'
    expect(result.trim()).toBe(expected)
})

test('It should generate deterministic dates for the same seed.', async () => {
    const doc = `<Root seed="1">
        <Document>
            <Text>
                <Date />
                <Date format="yyyy-MM-dd hh:mm:ss.SSS" />
                <Date when="recent" format="yyyy-MM-dd hh:mm:ss.SSS" />
                <Date when="past" format="yyyy-MM-dd hh:mm:ss.SSS" />
                <Date when="soon" format="yyyy-MM-dd hh:mm:ss.SSS" />
                <Date when="future" format="yyyy-MM-dd hh:mm:ss.SSS" />
            </Text>
        </Document>
    </Root>`

    const first = new TestParser()
    const second = new TestParser()

    const [firstResult, secondResult] = await Promise.all([
        first.parse(doc),
        second.parse(doc),
    ])

    expect(firstResult.trim()).toBe(secondResult.trim())
})

test('It should allow configuring refDate through parser options.', async () => {
    const doc = `<Root seed="1">
        <Document>
            <Text>
                <Date when="past" format="yyyy-MM-dd" />
            </Text>
        </Document>
    </Root>`

    const early = new TestParser({ refDate: '2020-01-01T00:00:00.000Z' })
    const late = new TestParser({ refDate: '2030-01-01T00:00:00.000Z' })

    const [earlyResult, lateResult] = await Promise.all([
        early.parse(doc),
        late.parse(doc),
    ])

    expect(earlyResult.trim()).not.toBe(lateResult.trim())
})

test('It should allow overriding refDate on Root.', async () => {
    const defaultDoc = `<Root seed="1">
        <Document>
            <Text>
                <Date when="past" format="yyyy-MM-dd" />
            </Text>
        </Document>
    </Root>`

    const overriddenDoc = `<Root seed="1" refDate="2030-01-01T00:00:00.000Z">
        <Document>
            <Text>
                <Date when="past" format="yyyy-MM-dd" />
            </Text>
        </Document>
    </Root>`

    const parser = new TestParser({ refDate: '2020-01-01T00:00:00.000Z' })
    const defaultResult = await parser.parse(defaultDoc)
    const overriddenResult = await parser.parse(overriddenDoc)

    expect(defaultResult.trim()).not.toBe(overriddenResult.trim())
})

test('It should parse <Date /> with default attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text>
                <Date />
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toMatch(/\d{4}-\d{2}-\d{2}/)
})

test('It should parse <Date /> with default attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text>
                <Date/>
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toMatch(/\d{2}:\d{2}:\d{2}.\d{3}/)
})

test('It should parse <Date /> with format attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Document>
            <Text>
                <Date format="hh:mm:ss.SSS" />
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toMatch(/\d{2}:\d{2}:\d{2}.\d{3}/)
})

test('It should parse <Date /> with when attributes.', async ({ parser }) => {
    const docPast = `<Root seed="1">
        <Document>
            <Text>
                <Date when="past" />
            </Text>
        </Document>
    </Root>`

    const resultPast = await parser.parse(docPast)
    expect(resultPast.trim()).toMatch(/\d{4}-\d{2}-\d{2}/)

    const docSoon = `<Root seed="1">
        <Document>
            <Text>
                <Date when="soon" />
            </Text>
        </Document>
    </Root>`

    const resultSoon = await parser.parse(docSoon)
    expect(resultSoon.trim()).toMatch(/\d{4}-\d{2}-\d{2}/)

    const docFuture = `<Root seed="1">
        <Document>
            <Text>
                <Date when="future" />
            </Text>
        </Document>
    </Root>`

    const resultFuture = await parser.parse(docFuture)
    expect(resultFuture.trim()).toMatch(/\d{4}-\d{2}-\d{2}/)
    
})

test('It should parse <UseTemplate /> with default attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Template name="greeting">
            <Text>
                Hello, {nameVar}!
            </Text>
        </Template>

        <Document>
            <Text>
                <UseTemplate ref="greeting" nameVar="Lorem" />
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toBe('Hello, Lorem!')
})

test('It should parse <Person /> with default attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Person ref="lorem" />
        <Document>
            <Text>
                <UsePerson ref="lorem">
                    <Prefix/> <LastName />, <FirstName/> <MiddleName/>
                </UsePerson>
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toBe('Ms. Terry, Felicia Violet')
})

test('It should parse localized <Person /> with default attributes.', async ({ parser }) => {
    const doc = `<Root seed="1" locale="de">
        <Person ref="lorem" />
        <Document>
            <Text>
                <UsePerson ref="lorem">
                    <Prefix/> <LastName />, <FirstName/> <MiddleName/>
                </UsePerson>
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toBe('Frau Schumacher, Cedric Kyle')
})

test('It should parse <Location /> with default attributes.', async ({ parser }) => {
    const doc = `<Root seed="1">
        <Location ref="loc_1" />
        <Document>
            <Text>
                <UseLocation ref="loc_1">
                    <Address />
                </UseLocation>
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toBe('7031 Christy Grove, New Heaven, Ohio 80645 Bulgaria')
})

test('It should parse <Location /> with locale root attributes.', async ({ parser }) => {
    const doc = `<Root seed="1" locale="de">
        <Location ref="loc_1" />
        <Document>
            <Text>
                <UseLocation ref="loc_1">
                    <Street /> <City />, <State /> <Zip /> <Country />
                </UseLocation>
            </Text>
        </Document>
    </Root>`

    const result = await parser.parse(doc)
    expect(result.trim()).toBe('Hans-Schlehahn-Str. 13b Nord Darrendorf, Hessen 54628 Algerien')
})