/**
 * create-data-ooc Controller Unit Tests
 * DataOoc 생성 컨트롤러 테스트
 */

import { TestDatabase } from '../../../../../test/test-database'
import { withTestTransaction } from '../../../../../test/test-context'
import {
  domainFactory,
  userFactory,
  dataSetFactory,
  dataSampleFactory,
  dataOocFactory
} from '../../../../../test/factories'
import { DataOocStatus } from '../../../../../test/entities/schemas'

describe('create-data-ooc Controller', () => {
  let testDb: TestDatabase

  beforeAll(async () => {
    testDb = TestDatabase.getInstance()
  })

  describe('DataOoc 생성 기본 동작', () => {
    it('DataSample에서 DataOoc 생성 시 ISSUED 상태로 생성되어야 한다', async () => {
      await withTestTransaction(async (context) => {
        const { tx, domain, user } = context.state

        // Given: DataSet과 OOC 조건의 DataSample
        const dataSet = await dataSetFactory.createWithDomain({}, domain, tx)
        const dataSample = await dataSampleFactory.createOocSample({}, dataSet, tx)

        // When: DataOoc 생성 시뮬레이션 (createDataOoc 로직)
        const dataOoc = await tx.save('DataOoc', {
          ...dataSample,
          name: `OOC-${dataSet.name}-${Date.now()}`,
          history: [
            {
              user: {
                id: user.id,
                username: user.email,
                name: user.name
              },
              state: DataOocStatus.ISSUED,
              timestamp: dataSample.collectedAt
            }
          ],
          state: DataOocStatus.ISSUED,
          dataSample,
          dataSet,
          domain
        })

        // Then
        expect(dataOoc).toBeDefined()
        expect(dataOoc.state).toBe(DataOocStatus.ISSUED)
        expect(dataOoc.history).toBeDefined()
        expect(dataOoc.history.length).toBe(1)
        expect(dataOoc.history[0].state).toBe(DataOocStatus.ISSUED)
      })
    })

    it('DataOoc 생성 시 DataSample의 data, judgment, ooc, oos가 복사되어야 한다', async () => {
      await withTestTransaction(async (context) => {
        const { tx, domain, user } = context.state

        // Given
        const dataSet = await dataSetFactory.createWithDomain({}, domain, tx)
        const sampleData = { temperature: 95, humidity: 50 }
        const sampleJudgment = {
          temperature: { ooc: true, oos: false },
          humidity: { ooc: false, oos: false }
        }
        const dataSample = await dataSampleFactory.createWithDataSet(
          {
            data: sampleData,
            judgment: sampleJudgment,
            ooc: true,
            oos: false
          },
          dataSet,
          domain,
          tx
        )

        // When: DataOoc 생성 (createDataOoc 로직 시뮬레이션)
        const dataOoc = await tx.save('DataOoc', {
          name: `OOC-${dataSet.name}`,
          data: dataSample.data,
          judgment: dataSample.judgment,
          ooc: dataSample.ooc,
          oos: dataSample.oos,
          collectedAt: dataSample.collectedAt,
          workDate: dataSample.workDate,
          workShift: dataSample.workShift,
          history: [
            {
              user: { id: user.id, name: user.name },
              state: DataOocStatus.ISSUED,
              timestamp: dataSample.collectedAt
            }
          ],
          state: DataOocStatus.ISSUED,
          dataSample,
          dataSet,
          domain
        })

        // Then
        expect(dataOoc.data).toEqual(sampleData)
        expect(dataOoc.judgment).toEqual(sampleJudgment)
        expect(dataOoc.ooc).toBe(true)
        expect(dataOoc.oos).toBe(false)
      })
    })

    it('DataOoc 생성 시 history의 첫 번째 엔트리는 생성자 정보를 포함해야 한다', async () => {
      await withTestTransaction(async (context) => {
        const { tx, domain, user } = context.state

        // Given
        const dataSet = await dataSetFactory.createWithDomain({}, domain, tx)
        const dataSample = await dataSampleFactory.createOocSample({}, dataSet, tx)
        const collectedAt = new Date()

        // When
        const dataOoc = await tx.save('DataOoc', {
          name: `OOC-${dataSet.name}`,
          data: dataSample.data,
          ooc: true,
          collectedAt,
          history: [
            {
              user: {
                id: user.id,
                username: user.email,
                name: user.name
              },
              state: DataOocStatus.ISSUED,
              timestamp: collectedAt
            }
          ],
          state: DataOocStatus.ISSUED,
          dataSample,
          dataSet,
          domain
        })

        // Then
        expect(dataOoc.history[0].user.id).toBe(user.id)
        expect(dataOoc.history[0].user.name).toBe(user.name)
        expect(dataOoc.history[0].state).toBe(DataOocStatus.ISSUED)
        expect(dataOoc.history[0].timestamp).toEqual(collectedAt)
      })
    })

    it('DataOoc와 DataSample의 관계가 올바르게 설정되어야 한다', async () => {
      await withTestTransaction(async (context) => {
        const { tx, domain } = context.state

        // Given
        const dataSet = await dataSetFactory.createWithDomain({}, domain, tx)
        const dataSample = await dataSampleFactory.createOocSample({}, dataSet, tx)

        // When
        const dataOoc = await dataOocFactory.createWithDataSetAndSample(
          { state: DataOocStatus.ISSUED },
          dataSet,
          dataSample,
          tx
        )

        // Then: 관계 확인
        expect(dataOoc.dataSample?.id).toBe(dataSample.id)
        expect(dataOoc.dataSet?.id).toBe(dataSet.id)
        expect(dataOoc.domain?.id).toBe(domain.id)
      })
    })
  })

  describe('DataOoc 생성 엣지 케이스', () => {
    it('ooc=true, oos=true인 경우 둘 다 저장되어야 한다', async () => {
      await withTestTransaction(async (context) => {
        const { tx, domain, user } = context.state

        // Given
        const dataSet = await dataSetFactory.createWithDomain({}, domain, tx)
        const dataSample = await dataSampleFactory.createWithDataSet(
          {
            data: { temperature: 150 }, // 스펙 초과
            ooc: true,
            oos: true
          },
          dataSet,
          domain,
          tx
        )

        // When
        const dataOoc = await tx.save('DataOoc', {
          name: `OOC-${dataSet.name}`,
          data: dataSample.data,
          ooc: true,
          oos: true,
          collectedAt: new Date(),
          history: [
            {
              user: { id: user.id, name: user.name },
              state: DataOocStatus.ISSUED,
              timestamp: new Date()
            }
          ],
          state: DataOocStatus.ISSUED,
          dataSample,
          dataSet,
          domain
        })

        // Then
        expect(dataOoc.ooc).toBe(true)
        expect(dataOoc.oos).toBe(true)
      })
    })

    it('collectedAt이 정확히 복사되어야 한다', async () => {
      await withTestTransaction(async (context) => {
        const { tx, domain, user } = context.state

        // Given
        const specificDate = new Date('2024-01-15T10:30:00.000Z')
        const dataSet = await dataSetFactory.createWithDomain({}, domain, tx)
        const dataSample = await dataSampleFactory.createWithDataSet(
          {
            collectedAt: specificDate,
            ooc: true
          },
          dataSet,
          domain,
          tx
        )

        // When
        const dataOoc = await tx.save('DataOoc', {
          name: `OOC-${dataSet.name}`,
          data: dataSample.data,
          ooc: true,
          collectedAt: dataSample.collectedAt,
          history: [
            {
              user: { id: user.id, name: user.name },
              state: DataOocStatus.ISSUED,
              timestamp: dataSample.collectedAt
            }
          ],
          state: DataOocStatus.ISSUED,
          dataSample,
          dataSet,
          domain
        })

        // Then
        expect(dataOoc.collectedAt).toEqual(specificDate)
      })
    })

    it('workDate와 workShift가 정확히 복사되어야 한다', async () => {
      await withTestTransaction(async (context) => {
        const { tx, domain, user } = context.state

        // Given
        const dataSet = await dataSetFactory.createWithDomain({}, domain, tx)
        const dataSample = await dataSampleFactory.createWithDataSet(
          {
            workDate: '2024-01-15',
            workShift: 'night',
            ooc: true
          },
          dataSet,
          domain,
          tx
        )

        // When
        const dataOoc = await tx.save('DataOoc', {
          name: `OOC-${dataSet.name}`,
          data: dataSample.data,
          ooc: true,
          collectedAt: dataSample.collectedAt,
          workDate: dataSample.workDate,
          workShift: dataSample.workShift,
          history: [
            {
              user: { id: user.id, name: user.name },
              state: DataOocStatus.ISSUED,
              timestamp: new Date()
            }
          ],
          state: DataOocStatus.ISSUED,
          dataSample,
          dataSet,
          domain
        })

        // Then
        expect(dataOoc.workDate).toBe('2024-01-15')
        expect(dataOoc.workShift).toBe('night')
      })
    })
  })
})