import assert from 'node:assert/strict';
import { buildApp } from '../dist/app.js';
import { signAccessToken } from '../dist/auth/jwt.js';
import {
  DeviceControlError,
  DeviceControlService
} from '../dist/devices/device-control-service.js';

const managerAccess = {
  roles: ['STORE_ADMIN'],
  capabilities: ['device.read', 'device.write'],
  storeIds: ['11']
};
const issued = [];
const service = new DeviceControlService({
  async execute(sql) {
    if (sql.includes('FROM qipai_devices')) {
      if (sql.includes("device_type = 'SMART_SOCKET'")) {
        return [[{
          id: 52, deviceId: 'SOCKET_001', storeId: 11, roomId: 31,
          deviceType: 'SMART_SOCKET', status: 'ONLINE'
        }], []];
      }
      return [[{
        id: 51, deviceId: 'BOX_001', storeId: 11, roomId: 31,
        deviceType: 'CONTROL_BOX', status: 'ONLINE'
      }], []];
    }
    return [[], []];
  }
}, {
  async issue(input) {
    const payload = input.payloadFactory('1782120000001');
    issued.push({ ...input, payload });
    return { commandId: '1782120000001', status: 'PUBLISHED' };
  }
});
const context = {
  tenantId: '7', storeId: '11', roomId: '31', traceId: 'trace',
  access: managerAccess
};

await service.controlPower(context, { slot1: 'on', slot3: 'off' });
assert.equal(issued.at(-1).payload.action, 'ConctolPower');
await service.controlDoor(context, { order: 'open', holdopen: 1, delayTime: 4 });
assert.equal(issued.at(-1).payload.action, 'Crldoor');
await service.playTts(context, { content: '欢迎光临' });
assert.equal(issued.at(-1).payload.action, 'PlayTTS');
await service.stopTts(context);
assert.equal(issued.at(-1).payload.action, 'stopTTS');
await service.controlLed(context, 30);
assert.equal(issued.at(-1).payload.action, 'CrlLED');
await service.startTask(context, { minute: 120, type: 2, subID: 'SUB001' });
assert.equal(issued.at(-1).payload.action, 'task');
await service.extendTask(context, 30);
assert.equal(issued.at(-1).payload.action, 'addtask');
await service.cancelTask(context);
assert.equal(issued.at(-1).payload.action, 'canceltask');
await service.pairSubLock(context, 60);
assert.equal(issued.at(-1).payload.action, 'AddDevice');
await service.controlSubLock(context, {
  subID: 'SUB001', order: 'open', delayTime: 4
});
assert.equal(issued.at(-1).payload.action, 'CtrlDevice');
await service.readSmartSocket(context, 'workInfo');
assert.deepEqual(issued.at(-1).payload, { read: 'workInfo' });
await service.switchSmartSocket(context, { on: false, slotNum: 2 });
assert.deepEqual(issued.at(-1).payload, {
  action: 'off', id: '1782120000001', slotNum: 2
});
await service.scheduleSmartSocket(context, {
  taskNum: 1, action: 'on', mode: 'weekly', time: '18:30', weekdays: [5, 6]
});
assert.equal(issued.at(-1).payload.action, 'localtask');
assert.equal(issued.at(-1).payload.switch, 'on');
await service.clearSmartSocketTask(context, 1);
assert.equal(issued.at(-1).payload.action, 'clearTask');

await assert.rejects(
  () => service.controlSubLock(context, {
    subID: 'SUB001', order: 'factoryreset', dangerConfirmation: 'CONFIRM_FACTORY_RESET'
  }),
  (error) => error instanceof DeviceControlError
    && error.code === 'DEVICE_DANGEROUS_ACTION_FORBIDDEN'
);
const platformContext = {
  ...context,
  access: { roles: ['PLATFORM_ADMIN'], capabilities: [], storeIds: [] }
};
await service.controlSubLock(platformContext, {
  subID: 'SUB001', order: 'factoryreset', dangerConfirmation: 'CONFIRM_FACTORY_RESET'
});
assert.equal(issued.at(-1).payload.order, 'factoryreset');
assert.equal('dangerConfirmation' in issued.at(-1).payload, false);

await assert.rejects(
  () => service.controlPower({
    ...context,
    access: { roles: ['STAFF'], capabilities: ['device.write'], storeIds: ['12'] }
  }, { slot1: 'on' }),
  (error) => error.code === 'DEVICE_SCOPE_FORBIDDEN'
);

const secret = 'test-only-jwt-secret-with-at-least-32-characters';
const token = signAccessToken({
  sub: '22', sid: '5c4d3af8-c63c-4edb-bf95-b84127bb3f6e',
  tid: '7', aid: '9', rv: 1
}, secret, 900);
let routed;
let routedContext;
const app = await buildApp({
  deviceControl: {
    jwtSecret: secret,
    authRepository: {
      async validateSession() {
        return {
          id: '5c4d3af8-c63c-4edb-bf95-b84127bb3f6e',
          tenantId: '7', platformAppId: '9', expiresAt: new Date(Date.now() + 60000),
          user: {
            id: '22', tenantId: '7', userType: 'STAFF', status: 'ACTIVE',
            roleVersion: 1, nickname: '', avatarUrl: '', phone: ''
          }
        };
      }
    },
    accessControl: { async getAccessProfile() { return managerAccess; } },
    customerAccess: {
      async getDoorContext(input) {
        assert.deepEqual(input, { tenantId: '7', userId: '22', orderId: '31' });
        return { orderId: '31', storeId: '11', roomId: '31', status: 'IN_PROGRESS' };
      }
    },
    service: {
      async controlPower(_context, input) { routed = input; return { status: 'PUBLISHED' }; },
      async controlDoor(context, input) {
        routedContext = context;
        routed = input;
        return { commandId: 'cmd-door', status: 'PUBLISHED' };
      },
      async playTts() { return {}; },
      async stopTts() { return {}; },
      async controlLed() { return {}; },
      async startTask() { return {}; },
      async extendTask() { return {}; },
      async cancelTask() { return {}; },
      async pairSubLock() { return {}; },
      async controlSubLock() { return {}; },
      async readSmartSocket() { return {}; },
      async switchSmartSocket(_context, input) { routed = input; return { status: 'PUBLISHED' }; },
      async scheduleSmartSocket() { return {}; },
      async clearSmartSocketTask() { return {}; }
    }
  }
});
const response = await app.inject({
  method: 'POST',
  url: '/admin-api/device-control/power',
  headers: { authorization: `Bearer ${token}` },
  payload: { storeId: '11', roomId: '31', slot1: 'on' }
});
assert.equal(response.statusCode, 200);
assert.equal(routed.slot1, 'on');
const socketResponse = await app.inject({
  method: 'POST',
  url: '/admin-api/device-control/socket/switch',
  headers: { authorization: `Bearer ${token}` },
  payload: { storeId: '11', roomId: '31', on: true, slotNum: 1 }
});
assert.equal(socketResponse.statusCode, 200);
assert.equal(routed.on, true);
const invalid = await app.inject({
  method: 'POST',
  url: '/admin-api/device-control/door',
  headers: { authorization: `Bearer ${token}` },
  payload: { storeId: '11', roomId: '31', order: 'open', delayTime: 15 }
});
assert.equal(invalid.statusCode, 400);
const appOpenDoor = await app.inject({
  method: 'POST',
  url: '/app-api/orders/31/open-door',
  headers: { authorization: `Bearer ${token}`, 'x-trace-id': 'm08a-open-door' },
  payload: { delayTime: 4, holdopen: 1 }
});
assert.equal(appOpenDoor.statusCode, 400);
const appOpenDoorOk = await app.inject({
  method: 'POST',
  url: '/app-api/orders/31/open-door',
  headers: { authorization: `Bearer ${token}`, 'x-trace-id': 'm08a-open-door' },
  payload: { delayTime: 4 }
});
assert.equal(appOpenDoorOk.statusCode, 200);
assert.equal(routed.order, 'open');
assert.equal(routed.holdopen, 0);
assert.equal(routedContext.orderId, '31');
assert.equal(routedContext.traceId, 'm08a-open-door');
assert.deepEqual(routedContext.access.capabilities, ['device.write']);
await app.close();

console.log('PASS: M06-E device control commands include control-box, Sub-1G and smart socket.');