import 'reflect-metadata';
import assert from 'node:assert/strict';
import test from 'node:test';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { ChangeInspectionVisitStatusDto } from '../../src/inspection-visits/dto/change-inspection-visit-status.dto';
import { CreateInspectionVisitDto } from '../../src/inspection-visits/dto/create-inspection-visit.dto';
import { ReplaceInspectionVisitAssetsDto } from '../../src/inspection-visits/dto/replace-inspection-visit-assets.dto';
import { ReplaceInspectionVisitTeamDto } from '../../src/inspection-visits/dto/replace-inspection-visit-team.dto';
import { UpdateInspectionVisitDto } from '../../src/inspection-visits/dto/update-inspection-visit.dto';

const AREA_ID = '16e54e65-60cf-4739-b0d1-ccdd904fbfd5';
const COMPANY_ID = 'ce96211d-ac15-4421-8868-4185323aff61';
const USER_ID = '9e38a67b-d6b1-49e0-8ec3-69a68366bd88';

test('visit DTO accepts only the minimum planning data required for quick creation', async () => {
  const dto = plainToInstance(CreateInspectionVisitDto, {
    operationalAreaId: AREA_ID,
    operatorCompanyId: COMPANY_ID,
    plannedStartAt: '2026-08-17T12:00:00.000Z',
    leadInspectorUserId: USER_ID,
  });
  assert.deepEqual(await validate(dto), []);
  assert.equal(dto.operationalAreaId, AREA_ID);
  assert.equal(dto.operatorCompanyId, COMPANY_ID);
  assert.equal(dto.leadInspectorUserId, USER_ID);
});

test('visit update DTO keeps Area, Yacimiento and Operadora immutable after creation', async () => {
  const contextAttempt = plainToInstance(UpdateInspectionVisitDto, {
    operationalAreaId: AREA_ID,
    scopeAssetId: AREA_ID,
    operatorCompanyId: COMPANY_ID,
  });
  const errors = await validate(contextAttempt);
  assert.equal(errors.some((error) => error.property === 'operationalAreaId'), true);
  assert.equal(errors.some((error) => error.property === 'scopeAssetId'), true);
  assert.equal(errors.some((error) => error.property === 'operatorCompanyId'), true);

  const ordinaryUpdate = plainToInstance(UpdateInspectionVisitDto, {
    objective: 'Control preventivo programado',
    plannedStartAt: '2026-09-17T12:00:00.000Z',
    instructions: 'Coordinar ingreso con la Operadora.',
  });
  assert.deepEqual(await validate(ordinaryUpdate), []);
});

test('asset and team DTOs reject duplicate references', async () => {
  const assets = Object.assign(new ReplaceInspectionVisitAssetsDto(), {
    assetIds: [AREA_ID, AREA_ID],
  });
  const team = Object.assign(new ReplaceInspectionVisitTeamDto(), {
    leadInspectorUserId: USER_ID,
    memberUserIds: [USER_ID, USER_ID],
  });
  assert.equal((await validate(assets)).some((error) => error.property === 'assetIds'), true);
  assert.equal((await validate(team)).some((error) => error.property === 'memberUserIds'), true);
});

test('status DTO accepts controlled states and rejects unknown transitions at input', async () => {
  const dto = Object.assign(new ChangeInspectionVisitStatusDto(), {
    status: 'PLANNED',
    reason: null,
  });
  assert.deepEqual(await validate(dto), []);
  dto.status = 'OPEN' as typeof dto.status;
  assert.equal((await validate(dto)).some((error) => error.property === 'status'), true);
});