'use strict';

/**
 * Integration tests – partner controller (controllers/partner.js)
 */

const { connectDB, disconnectDB, clearCollection } = require('./jest.setup');
const { mockApplicator, mockReq, mockRes, newId } = require('./mock_data');

let Partner, Customer, PartnerSystemUser;

beforeAll(async () => {
  await connectDB();
  Customer = require('../../model/customer');
  // Ensure partner discriminator is registered
  const partnerModel = require('../../model/partner');
  Partner = partnerModel.Partner || partnerModel;
  PartnerSystemUser = partnerModel.PartnerSystemUser;
});

afterAll(async () => {
  await disconnectDB();
});

const partnerCtl = require('../../controllers/partner');

describe('partner controller – data methods', () => {
  let admin;

  function makePartnerBody() {
    return {
      name: `Partner-${Date.now()}`,
      username: `partner_${Date.now()}@test.com`,
      password: 'Test@123',
      active: true,
      kind: '20',
      partnerCode: `TESTCODE-${Date.now()}`,
    };
  }

  beforeAll(async () => {
    await clearCollection(Partner);
    admin = await Customer.create(mockApplicator());
  });

  afterAll(async () => {
    await clearCollection(Partner);
    await Customer.deleteMany({ _id: admin._id });
  });

  const makeReq = (extra = {}) =>
    mockReq({ uid: admin._id, puid: admin._id, ut: '1', ...extra });

  // -------------------------------------------------------------------------
  describe('createPartner_post', () => {
    it('creates a partner and returns it', async () => {
      const req = makeReq({ body: makePartnerBody() });
      const res = mockRes();

      await partnerCtl.createPartner_post(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(res._data._id).toBeDefined();
      expect(res._data.kind).toBe('20');
    });

    it('throws when body is missing', async () => {
      const req = makeReq({ body: null });
      const res = mockRes();
      await expect(partnerCtl.createPartner_post(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('getPartners_get', () => {
    it('returns array of partners', async () => {
      const req = makeReq({ query: {} });
      const res = mockRes();

      await partnerCtl.getPartners_get(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(Array.isArray(res._data)).toBe(true);
    });
  });

  // -------------------------------------------------------------------------
  describe('getPartners_post', () => {
    it('returns partners matching search criteria', async () => {
      const req = makeReq({ body: { name: 'Partner' } });
      const res = mockRes();

      await partnerCtl.getPartners_post(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(Array.isArray(res._data)).toBe(true);
    });
  });

  // -------------------------------------------------------------------------
  describe('getPartnerById_get', () => {
    let partnerId;

    beforeAll(async () => {
      const req = makeReq({ body: makePartnerBody() });
      const res = mockRes();
      await partnerCtl.createPartner_post(req, res);
      partnerId = String(res._data._id);
    });

    it('returns partner by id', async () => {
      const req = makeReq({ params: { id: partnerId } });
      const res = mockRes();

      await partnerCtl.getPartnerById_get(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(String(res._data._id)).toBe(partnerId);
    });

    it('throws when partner id is invalid', async () => {
      const req = makeReq({ params: { id: 'invalid-id' } });
      const res = mockRes();
      await expect(partnerCtl.getPartnerById_get(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('getPartnerById_post', () => {
    let partnerId;

    beforeAll(async () => {
      const req = makeReq({ body: makePartnerBody() });
      const res = mockRes();
      await partnerCtl.createPartner_post(req, res);
      partnerId = String(res._data._id);
    });

    it('returns partner by id from body', async () => {
      const req = makeReq({ body: { partner: partnerId } });
      const res = mockRes();

      await partnerCtl.getPartnerById_post(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(String(res._data._id)).toBe(partnerId);
    });

    it('throws when partner id is missing from body', async () => {
      const req = makeReq({ body: {} });
      const res = mockRes();
      await expect(partnerCtl.getPartnerById_post(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('updatePartner_put', () => {
    let partnerId;

    beforeAll(async () => {
      const req = makeReq({ body: makePartnerBody() });
      const res = mockRes();
      await partnerCtl.createPartner_post(req, res);
      partnerId = String(res._data._id);
    });

    it('updates a partner field', async () => {
      const req = makeReq({
        params: { id: partnerId },
        body: { name: 'Updated Partner Name', kind: '20' },
      });
      const res = mockRes();

      await partnerCtl.updatePartner_put(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(res._data.name).toBe('Updated Partner Name');
    });
  });

  // -------------------------------------------------------------------------
  describe('deletePartner', () => {
    let partnerId;

    beforeAll(async () => {
      const req = makeReq({ body: makePartnerBody() });
      const res = mockRes();
      await partnerCtl.createPartner_post(req, res);
      partnerId = String(res._data._id);
    });

    it('soft-deletes a partner', async () => {
      const req = makeReq({ params: { id: partnerId } });
      const res = mockRes();

      await partnerCtl.deletePartner(req, res);

      expect(res.json).toHaveBeenCalled();
      const found = await Partner.findById(partnerId);
      expect(!found || found.active === false).toBeTruthy();
    });
  });

  // -------------------------------------------------------------------------
  describe('syncData_post', () => {
    it('returns 500 json response when partnerCode or customer is missing', async () => {
      const req = makeReq({ body: {} });
      const res = mockRes();

      await partnerCtl.syncData_post(req, res);

      expect(res.status).toHaveBeenCalledWith(500);
      expect(res.json).toHaveBeenCalled();
      expect(res._data.success).toBe(false);
    });

    it('returns success when partnerCode and customer are provided', async () => {
      const req = makeReq({
        body: { partnerCode: 'TEST', customer: String(admin._id) },
      });
      const res = mockRes();

      await partnerCtl.syncData_post(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(res._data.success).toBe(true);
    });
  });

  // -------------------------------------------------------------------------
  describe('uploadJob_post', () => {
    it('returns 500 json response when required params are missing', async () => {
      const req = makeReq({ body: {} });
      const res = mockRes();

      await partnerCtl.uploadJob_post(req, res);

      expect(res.status).toHaveBeenCalledWith(500);
      expect(res.json).toHaveBeenCalled();
      expect(res._data.success).toBe(false);
    });
  });

  // -------------------------------------------------------------------------
  describe('getSystemUsers_get', () => {
    it('returns empty array when no system users exist for valid partner+customer pair', async () => {
      const req = makeReq({
        query: { partnerId: String(newId()), customerId: String(admin._id) },
      });
      const res = mockRes();

      await partnerCtl.getSystemUsers_get(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(Array.isArray(res._data)).toBe(true);
    });

    it('throws when partnerId is not a valid ObjectId', async () => {
      const req = makeReq({
        query: { partnerId: 'bad-id', customerId: String(admin._id) },
      });
      const res = mockRes();
      await expect(partnerCtl.getSystemUsers_get(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('getCurrentSystemUser_get', () => {
    it('throws NOT_FOUND when no active system user exists', async () => {
      const req = makeReq({
        query: { partnerId: String(newId()), customerId: String(admin._id) },
      });
      const res = mockRes();
      await expect(partnerCtl.getCurrentSystemUser_get(req, res)).rejects.toThrow();
    });

    it('throws when params are invalid', async () => {
      const req = makeReq({
        query: { partnerId: 'bad-id', customerId: 'bad-id' },
      });
      const res = mockRes();
      await expect(partnerCtl.getCurrentSystemUser_get(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('getSystemUser_get', () => {
    it('throws when id is missing', async () => {
      const req = makeReq({ params: {} });
      const res = mockRes();
      await expect(partnerCtl.getSystemUser_get(req, res)).rejects.toThrow();
    });

    it('throws NOT_FOUND when id does not match any system user', async () => {
      const req = makeReq({ params: { id: String(newId()) } });
      const res = mockRes();
      await expect(partnerCtl.getSystemUser_get(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('createSystemUser_post', () => {
    let partner;

    beforeAll(async () => {
      const req = makeReq({ body: makePartnerBody() });
      const res = mockRes();
      await partnerCtl.createPartner_post(req, res);
      partner = res._data;
    });

    it('throws when required params are missing', async () => {
      const req = makeReq({ body: { partnerId: String(partner._id) } });
      const res = mockRes();
      await expect(partnerCtl.createSystemUser_post(req, res)).rejects.toThrow();
    });

    it('creates a partner system user for valid partner+customer', async () => {
      const req = makeReq({
        body: {
          partnerId: String(partner._id),
          customerId: String(admin._id),
          username: `psu_${Date.now()}@test.com`,
          password: 'Pass@123',
          name: 'Test PSU',
        },
      });
      const res = mockRes();

      await partnerCtl.createSystemUser_post(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(res._data._id).toBeDefined();
    });
  });

  // -------------------------------------------------------------------------
  describe('updateSystemUser_put', () => {
    let systemUserId, partner;

    beforeAll(async () => {
      const pReq = makeReq({ body: makePartnerBody() });
      const pRes = mockRes();
      await partnerCtl.createPartner_post(pReq, pRes);
      partner = pRes._data;

      const req = makeReq({
        body: {
          partnerId: String(partner._id),
          customerId: String(admin._id),
          username: `psu2_${Date.now()}@test.com`,
          password: 'Pass@123',
        },
      });
      const res = mockRes();
      await partnerCtl.createSystemUser_post(req, res);
      systemUserId = String(res._data._id);
    });

    it('updates a system user field via updateUser_put', async () => {
      const req = makeReq({
        params: { id: systemUserId },
        body: { name: 'Updated PSU Name', kind: '21' },
      });
      const res = mockRes();

      await partnerCtl.updateSystemUser_put(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(res._data.name).toBe('Updated PSU Name');
    });
  });

  // -------------------------------------------------------------------------
  describe('updateSystemUser_post', () => {
    let systemUserId, partner;

    beforeAll(async () => {
      const pReq = makeReq({ body: makePartnerBody() });
      const pRes = mockRes();
      await partnerCtl.createPartner_post(pReq, pRes);
      partner = pRes._data;

      const req = makeReq({
        body: {
          partnerId: String(partner._id),
          customerId: String(admin._id),
          username: `psu3_${Date.now()}@test.com`,
          password: 'Pass@123',
        },
      });
      const res = mockRes();
      await partnerCtl.createSystemUser_post(req, res);
      systemUserId = String(res._data._id);
    });

    it('updates system user fields via patch approach', async () => {
      const req = makeReq({
        params: { id: systemUserId },
        body: { name: 'PATCH Updated PSU' },
      });
      const res = mockRes();

      await partnerCtl.updateSystemUser_post(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(res._data.name).toBe('PATCH Updated PSU');
    });

    it('throws NOT_FOUND for non-existent system user id', async () => {
      const req = makeReq({
        params: { id: String(newId()) },
        body: { name: 'X' },
      });
      const res = mockRes();
      await expect(partnerCtl.updateSystemUser_post(req, res)).rejects.toThrow();
    });

    it('throws when id is missing', async () => {
      const req = makeReq({ params: {}, body: { name: 'X' } });
      const res = mockRes();
      await expect(partnerCtl.updateSystemUser_post(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('deleteSystemUser', () => {
    let systemUserId, partner;

    beforeAll(async () => {
      const pReq = makeReq({ body: makePartnerBody() });
      const pRes = mockRes();
      await partnerCtl.createPartner_post(pReq, pRes);
      partner = pRes._data;

      const req = makeReq({
        body: {
          partnerId: String(partner._id),
          customerId: String(admin._id),
          username: `psu4_${Date.now()}@test.com`,
          password: 'Pass@123',
        },
      });
      const res = mockRes();
      await partnerCtl.createSystemUser_post(req, res);
      systemUserId = String(res._data._id);
    });

    it('soft-deletes a system user (marks inactive)', async () => {
      const req = makeReq({ params: { id: systemUserId } });
      const res = mockRes();

      await partnerCtl.deleteSystemUser(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(res._data.ok).toBe(true);
    });

    it('throws NOT_FOUND for non-existent system user', async () => {
      const req = makeReq({ params: { id: String(newId()) } });
      const res = mockRes();
      await expect(partnerCtl.deleteSystemUser(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('testPartnerAuth_post', () => {
    it('throws when required params are missing', async () => {
      const req = makeReq({ body: { customerId: String(admin._id) } });
      const res = mockRes();
      await expect(partnerCtl.testPartnerAuth_post(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('getPartnerCustomers_get', () => {
    let partnerId;

    beforeAll(async () => {
      const req = makeReq({ body: makePartnerBody() });
      const res = mockRes();
      await partnerCtl.createPartner_post(req, res);
      partnerId = String(res._data._id);
    });

    it('returns empty array when no system users exist for the partner', async () => {
      const req = makeReq({ query: { partnerId } });
      const res = mockRes();

      await partnerCtl.getPartnerCustomers_get(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(Array.isArray(res._data)).toBe(true);
    });

    it('throws when partnerId is missing', async () => {
      const req = makeReq({ query: {} });
      const res = mockRes();
      await expect(partnerCtl.getPartnerCustomers_get(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('getPartnerAircraft_get', () => {
    it('throws when customerId is not a valid ObjectId', async () => {
      const req = makeReq({ query: { partnerId: String(newId()), customerId: 'bad-id' } });
      const res = mockRes();
      await expect(partnerCtl.getPartnerAircraft_get(req, res)).rejects.toThrow();
    });

    it('returns a 422 response when partner is not found', async () => {
      const req = makeReq({
        query: { partnerId: String(newId()), customerId: String(admin._id) },
      });
      const res = mockRes();

      await partnerCtl.getPartnerAircraft_get(req, res);

      expect(res.status).toHaveBeenCalledWith(422);
      expect(res.json).toHaveBeenCalled();
      expect(res._data.success).toBe(false);
    });
  });
});