import "reflect-metadata"
import { DataSource } from "../../../src"
import {
    closeTestingConnections,
    createTestingConnections,
    reloadTestingDatabases,
} from "../../utils/test-utils"
import { Order } from "./entity/order"
import { OrderTestEntity } from "./entity/order-test.entity"

describe("github issues > #7651 Enum that contains functions is not accordingly translated to SQL", () => {
    describe("entity", () => {
        let connections: DataSource[]
        before(
            async () =>
                (connections = await createTestingConnections({
                    entities: [__dirname + "/entity/*{.js,.ts}"],
                    schemaCreate: true,
                    dropSchema: true,
                    enabledDrivers: ["postgres"],
                })),
        )
        beforeEach(() => reloadTestingDatabases(connections))
        after(() => closeTestingConnections(connections))

        it("should correctly save and retrieve enum fields when declaration merging technique is used and enum contains functions", () =>
            Promise.all(
                connections.map(async (connection) => {
                    // GIVEN
                    const orderEntity = new OrderTestEntity()
                    orderEntity.id = 1
                    orderEntity.order = Order.from("_2") // example of function call on enum to retrieve enum from string

                    const orderEntityRepository =
                        connection.getRepository(OrderTestEntity)
                    await orderEntityRepository.save(orderEntity)

                    // WHEN
                    const loadedOrderEntity =
                        await orderEntityRepository.findOneBy({ id: 1 })

                    // THEN
                    loadedOrderEntity!.order.should.be.eq(Order.SECOND)
                }),
            ))

        it("should correctly save and retrieve enum array", () =>
            Promise.all(
                connections.map(async (connection) => {
                    // GIVEN
                    const orderEntity = new OrderTestEntity()
                    orderEntity.id = 1
                    orderEntity.orders = [Order.from("_2"), Order.THIRD]

                    const orderEntityRepository =
                        connection.getRepository(OrderTestEntity)
                    await orderEntityRepository.save(orderEntity)

                    // WHEN
                    const loadedOrderEntity =
                        await orderEntityRepository.findOneBy({ id: 1 })

                    // THEN
                    loadedOrderEntity!.orders.should.be.eql([
                        Order.SECOND,
                        Order.THIRD,
                    ])
                }),
            ))
    })

    describe("schema", () => {
        let connections: DataSource[]
        before(
            async () =>
                (connections = await createTestingConnections({
                    entities: [__dirname + "/entity/*{.js,.ts}"],
                    schemaCreate: false,
                    dropSchema: true,
                    enabledDrivers: ["postgres"],
                    migrations: [],
                })),
        )
        after(() => closeTestingConnections(connections))

        it("should contain SQL for enum type without function", () =>
            Promise.all(
                connections.map(async (connection) => {
                    const sqlInMemory = await connection.driver
                        .createSchemaBuilder()
                        .log()

                    sqlInMemory!.upQueries.length.should.be.greaterThan(0)
                    sqlInMemory.upQueries.forEach((query) => {
                        // there should be no function string in query when our ENUM TYPE is provided
                        query.query.should.not.contain("function")
                    })
                }),
            ))
    })
})