tileMergeTaskManager.spec.ts

/* eslint-disable jest/no-commented-out-tests */
import { randomUUID } from 'crypto';
import nock from 'nock';
import { TileOutputFormat } from '@map-colonies/raster-shared';
import { ConflictError } from '@map-colonies/error-types';
import { configMock, registerDefaultConfig } from '../../mocks/configMock';
import { ingestionNewJob } from '../../mocks/jobsMockData';
import type { MergeTaskParameters, JobResumeState, MergeTilesTaskParams } from '../../../../src/common/interfaces';
import { IngestionCreateTasksTask } from '../../../../src/utils/zod/schemas/job.schema';
import { createFakeTask } from '../../mocks/tasksMockData';
import {
  createMergeTilesTaskParams,
  createTaskGenerator,
  type MergeTilesTaskBuilderContext,
  setupMergeTilesTaskBuilderTest,
} from './tileMergeTaskManagerSetup';

describe('tileMergeTaskManager', () => {
  const buildTasksParams = createMergeTilesTaskParams();
  let testContext: MergeTilesTaskBuilderContext;
  let mockInitTask: IngestionCreateTasksTask;
  beforeEach(() => {
    registerDefaultConfig();
    testContext = setupMergeTilesTaskBuilderTest();
    mockInitTask = createFakeTask<IngestionCreateTasksTask['parameters']>();
  });

  afterEach(() => {
    jest.clearAllMocks();
  });

  describe('buildTasks', () => {
    it('should handle initTask (fresh start)', async () => {
      const { tileMergeTaskManager } = testContext;

      // No taskIndex set - should default to fresh start

      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);

      // Collect tasks to verify fresh start works correctly
      const taskSample: MergeTaskParameters[] = [];
      const taskResumeSample: JobResumeState[] = [];
      const maxSamples = 5;

      for await (const task of tasks) {
        taskSample.push(task.mergeTasksGenerator);
        taskResumeSample.push(task.latestTaskIndex);
        if (taskSample.length >= maxSamples) {
          break;
        }
      }

      // Fresh start should generate tasks normally
      expect(taskSample).toHaveLength(5);

      taskResumeSample.forEach((taskIndex) => {
        expect(taskIndex.zoomLevel).toBeGreaterThanOrEqual(0);
        expect(taskIndex.lastInsertedTaskIndex).toBeGreaterThanOrEqual(0);
      });

      taskSample.forEach((task) => {
        expect(task.sources.length).toBeGreaterThan(0);
        expect(task.isNewTarget).toBe(true);
        expect(task.targetFormat).toBe(TileOutputFormat.PNG);
        expect(task.sources.length).toBeGreaterThan(0);
        expect(task.sources[0].path).toBe('layerRelativePath');
        expect(task.batches.length).toBeGreaterThan(0);
      });
    });

    it('should handle errors in buildTasks correctly', () => {
      const { tileMergeTaskManager } = testContext;
      const invalidBuildTasksParams: MergeTilesTaskParams = {
        ...buildTasksParams,
        inputFiles: {
          ...buildTasksParams.inputFiles,
          gpkgFilesPath: ['file1.gpkg', 'file2.gpkg'],
        },
      };

      const action = () => tileMergeTaskManager.buildTasks(invalidBuildTasksParams, mockInitTask);

      expect(action).toThrow();
    });

    it('resume state initialization - should handle initTask with valid resume parameters', async () => {
      const { tileMergeTaskManager } = testContext;

      const resumeZoomLevel = 6;

      mockInitTask.parameters.latestTaskState = {
        zoomLevel: resumeZoomLevel,
        lastInsertedTaskIndex: 2,
      };

      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);

      // Collect a small sample of tasks to verify business logic
      const taskSample: MergeTaskParameters[] = [];
      const taskResumeSample: JobResumeState[] = [];
      const maxSamples = 5;

      for await (const task of tasks) {
        taskSample.push(task.mergeTasksGenerator);
        taskResumeSample.push(task.latestTaskIndex);
        if (taskSample.length >= maxSamples) {
          break;
        }
      }

      // Explicit business logic assertions
      expect(taskSample).toHaveLength(5);

      taskResumeSample.forEach((taskIndex) => {
        expect(taskIndex.zoomLevel).toBeLessThanOrEqual(resumeZoomLevel);
        expect(taskIndex.lastInsertedTaskIndex).toBeGreaterThanOrEqual(0);
      });

      taskSample.forEach((task) => {
        expect(task.sources.length).toBeGreaterThan(0);
        expect(task.batches.length).toBeGreaterThan(0);
      });
    });

    it('resume state initialization - should handle initTask with boundary resume parameters', async () => {
      const { tileMergeTaskManager } = testContext;

      mockInitTask.parameters.latestTaskState = {
        zoomLevel: 0, // Minimum zoom
        lastInsertedTaskIndex: 0, // Start index
      };

      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);

      // Collect tasks to verify boundary conditions work
      const taskSample: MergeTaskParameters[] = [];
      const taskResumeSample: JobResumeState[] = [];
      const maxSamples = 2;

      for await (const task of tasks) {
        taskSample.push(task.mergeTasksGenerator);
        taskResumeSample.push(task.latestTaskIndex);
        if (taskSample.length >= maxSamples) {
          break;
        }
      }

      expect(taskSample.length).toBeGreaterThan(0);

      taskResumeSample.forEach((taskIndex) => {
        expect(taskIndex.zoomLevel).toBe(0);
        expect(taskIndex.lastInsertedTaskIndex).toBeGreaterThanOrEqual(0);
      });

      taskSample.forEach((task) => {
        expect(task.sources.length).toBeGreaterThan(0);
        expect(task.batches.length).toBeGreaterThan(0);
      });
    });

    it('resume state initialization - should handle high skip index values', async () => {
      const { tileMergeTaskManager } = testContext;

      mockInitTask.parameters.latestTaskState = {
        zoomLevel: 4,
        lastInsertedTaskIndex: 999, // High skip value
      };

      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);

      // Try to collect tasks with high skip value
      const taskSample: MergeTaskParameters[] = [];
      const taskResumeSample: JobResumeState[] = [];

      for await (const task of tasks) {
        taskSample.push(task.mergeTasksGenerator);
        taskResumeSample.push(task.latestTaskIndex);
      }

      // High skip values should not crash the system
      expect(taskSample.length).toBeGreaterThanOrEqual(0); // Likely 0 since skip value is very high

      // If any tasks are generated, they should be valid
      taskSample.forEach((task) => {
        expect(task.targetFormat).toBe(TileOutputFormat.PNG);
        expect(task.isNewTarget).toBe(true);
      });

      taskResumeSample.forEach((taskIndex) => {
        expect(taskIndex.zoomLevel).toBeLessThanOrEqual(4);
        expect(taskIndex.lastInsertedTaskIndex).toBeGreaterThanOrEqual(0);
      });

      const zoomLevels = taskResumeSample.map((taskIndex) => taskIndex.zoomLevel);
      expect(zoomLevels.filter((zoom) => zoom === 0).length).toBeGreaterThan(0);
      expect(zoomLevels.filter((zoom) => zoom === 1).length).toBeGreaterThan(0);
      expect(zoomLevels.filter((zoom) => zoom === 2).length).toBeGreaterThan(0);
      expect(zoomLevels.filter((zoom) => zoom === 3).length).toBeGreaterThan(0);
    });

    it('should handle malformed resume parameters gracefully', async () => {
      const { tileMergeTaskManager } = testContext;

      // Set malformed taskIndex
      mockInitTask.parameters.latestTaskState = {
        zoomLevel: -1, // Invalid zoom level
        lastInsertedTaskIndex: -5, // Invalid index
      };

      // Should not throw error - implementation should handle gracefully
      expect(() => {
        const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);
        expect(tasks).toBeDefined();
      }).not.toThrow();

      // Verify no tasks are generated with malformed parameters
      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);
      const taskSample: MergeTaskParameters[] = [];
      const taskResumeSample: JobResumeState[] = [];
      const maxSamples = 5;

      for await (const task of tasks) {
        taskSample.push(task.mergeTasksGenerator);
        taskResumeSample.push(task.latestTaskIndex);
        if (taskSample.length >= maxSamples) {
          break;
        }
      }

      // Expect no tasks to be pushed with malformed parameters
      expect(taskSample).toHaveLength(0);

      // Spy on updateTask to verify it's not called
      const updateTaskSpy = jest.spyOn(tileMergeTaskManager['queueClient'].jobManagerClient, 'updateTask');

      const jobId = randomUUID();
      await tileMergeTaskManager.pushTasks(mockInitTask, jobId, ingestionNewJob.type, tasks);

      // Expect updateJob to not be called when no tasks are processed
      expect(updateTaskSpy).not.toHaveBeenCalled();

      updateTaskSpy.mockRestore();
    });

    it('should complete full recovery cycle: build -> push with resume state', async () => {
      const { tileMergeTaskManager } = testContext;

      const jobId = randomUUID();

      // Simulate recovery scenario
      mockInitTask.parameters.latestTaskState = {
        zoomLevel: 3,
        lastInsertedTaskIndex: 0,
      };

      const jobManagerBaseUrl = configMock.get<string>('jobManagement.config.jobManagerBaseUrl');
      const createTasksPath = `/jobs/${jobId}/tasks`;
      const updateTaskPath = `/jobs/${jobId}/tasks/${mockInitTask.id}`;

      nock(jobManagerBaseUrl).post(createTasksPath).reply(200).persist();
      nock(jobManagerBaseUrl).put(updateTaskPath).reply(200).persist();

      // Execute full recovery cycle
      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);

      let error: Error | null = null;
      try {
        await tileMergeTaskManager.pushTasks(mockInitTask, jobId, ingestionNewJob.type, tasks);
      } catch (err) {
        error = err as Error;
      }

      // Verify successful completion
      expect(error).toBeNull();
    });
  });

  // describe('calculateIntersectionState', () => {
  //   // Test case 1: No intersection found
  //   it('should return null intersection when no overlap is found', () => {
  //     const { tileMergeTaskManager } = testContext;

  //     const { input } = testData[0];
  //     const result = tileMergeTaskManager['calculateIntersectionState'](input.state, input.subGroupFootprints);

  //     expect(result.currentIntersection).toBeNull();
  //     expect(result.accumulatedIntersection).toBeNull();
  //   });

  //   // Test case 2: Intersection found, no accumulated overlap
  //   it('should return intersection when found with no previous accumulated overlap', () => {
  //     const { tileMergeTaskManager } = testContext;
  //     const { input } = testData[1];

  //     const result = tileMergeTaskManager['calculateIntersectionState'](input.state, input.subGroupFootprints);
  //     const isCurrentEqualAccumulated = booleanEqual(result.currentIntersection as Feature, result.accumulatedIntersection as Feature);

  //     expect(result.currentIntersection).not.toBeNull();
  //     expect(result.accumulatedIntersection).not.toBeNull();
  //     expect(isCurrentEqualAccumulated).toBe(true);
  //   });

  //   // Test case 3: Intersection found, with accumulated overlap, new intersection
  //   it('should return new intersection and updated accumulated overlap', () => {
  //     const { tileMergeTaskManager } = testContext;
  //     const { input } = testData[2];
  //     const result = tileMergeTaskManager['calculateIntersectionState'](input.state, input.subGroupFootprints);
  //     const isCurrentEqualAccumulated = booleanEqual(result.currentIntersection as Feature, result.accumulatedIntersection as Feature);

  //     expect(result.currentIntersection).not.toBeNull();
  //     expect(result.accumulatedIntersection).not.toBeNull();
  //     expect(isCurrentEqualAccumulated).toBe(false);
  //   });

  //   // Test case 4: Intersection found, with accumulated overlap, no new intersection
  //   it('should return null intersection when new intersection is fully within accumulated overlap', () => {
  //     const { tileMergeTaskManager } = testContext;
  //     const { input } = testData[2];

  //     input.state.accumulatedIntersection = {
  //       type: 'Polygon',
  //       coordinates: [
  //         [
  //           [2, 2],
  //           [3, 2],
  //           [3, 3],
  //           [2, 3],
  //           [2, 2],
  //         ],
  //       ],
  //     };

  //     const result = tileMergeTaskManager['calculateIntersectionState'](input.state, input.subGroupFootprints);

  //     expect(result.currentIntersection).toBeNull();
  //     expect(result.accumulatedIntersection).not.toBeNull();
  //   });
  // });

  describe('pushTasks', () => {
    it('should push tasks in batches correctly', async () => {
      const { tileMergeTaskManager } = testContext;

      const jobId = randomUUID();

      const jobManagerBaseUrl = configMock.get<string>('jobManagement.config.jobManagerBaseUrl');
      const path = `/jobs/${jobId}/tasks`;
      const updatePath = `/jobs/${jobId}/tasks/${mockInitTask.id}`;
      nock(jobManagerBaseUrl).post(path).reply(200).persist();
      nock(jobManagerBaseUrl).put(updatePath).reply(200).persist();

      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);

      let error: Error | null = null;
      try {
        await tileMergeTaskManager.pushTasks(mockInitTask, jobId, ingestionNewJob.type, tasks);
      } catch (err) {
        error = err as Error;
      }

      expect(error).toBeNull();
    });

    it('should push leftover tasks correctly', async () => {
      const { tileMergeTaskManager } = testContext;
      const taskBatchSize = configMock.get<number>('jobManagement.ingestion.tasks.tilesMerging.taskBatchSize');
      const numberOfTasks = 3;
      const enqueueTasksTotal = Math.ceil(numberOfTasks / taskBatchSize);
      const jobId = randomUUID();

      const jobManagerBaseUrl = configMock.get<string>('jobManagement.config.jobManagerBaseUrl');
      const path = `/jobs/${jobId}/tasks`;
      const updatePath = `/jobs/${jobId}/tasks/${mockInitTask.id}`;
      nock(jobManagerBaseUrl).post(path).reply(200).persist();
      nock(jobManagerBaseUrl).put(updatePath).reply(200).persist();

      const tasks = createTaskGenerator(numberOfTasks);

      const enqueueTasksSpy = jest.spyOn(tileMergeTaskManager as unknown as { enqueueTasks: jest.Func }, 'enqueueTasks');

      let error: Error | null = null;
      try {
        await tileMergeTaskManager.pushTasks(mockInitTask, jobId, ingestionNewJob.type, tasks);
      } catch (err) {
        error = err as Error;
      }

      expect(error).toBeNull();
      expect(enqueueTasksSpy).toHaveBeenCalledTimes(enqueueTasksTotal);
    });

    it('should handle errors in pushTasks correctly', async () => {
      const { tileMergeTaskManager } = testContext;

      const jobId = randomUUID();

      const jobManagerBaseUrl = configMock.get<string>('jobManagement.config.jobManagerBaseUrl');
      const path = `/jobs/${jobId}/tasks`;
      nock(jobManagerBaseUrl).post(path).reply(500).persist();

      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);

      const action = async () => tileMergeTaskManager.pushTasks(mockInitTask, jobId, ingestionNewJob.type, tasks);

      await expect(action).rejects.toThrow();
    });

    it('should update initTask progress after pushTasks', async () => {
      const { tileMergeTaskManager } = testContext;

      const jobId = randomUUID();

      // Setup HTTP mocks for job manager interactions
      const jobManagerBaseUrl = configMock.get<string>('jobManagement.config.jobManagerBaseUrl');
      const createTasksPath = `/jobs/${jobId}/tasks`;
      const updateTaskPath = `/jobs/${jobId}/tasks/${mockInitTask.id}`;

      nock(jobManagerBaseUrl).post(createTasksPath).reply(200).persist();
      nock(jobManagerBaseUrl).put(updateTaskPath).reply(200).persist();

      // Spy on the job manager client methods
      const updateTaskSpy = jest.spyOn(tileMergeTaskManager['queueClient'].jobManagerClient, 'updateTask');
      const createTaskSpy = jest.spyOn(tileMergeTaskManager['queueClient'].jobManagerClient, 'createTaskForJob');

      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);
      await tileMergeTaskManager.pushTasks(mockInitTask, jobId, ingestionNewJob.type, tasks);

      // Verify progress tracking occurred
      expect(updateTaskSpy).toHaveBeenCalled();
      expect(updateTaskSpy.mock.calls.length).toBeGreaterThan(0);

      updateTaskSpy.mockRestore();
      createTaskSpy.mockRestore();
    });

    it('resume state initialization - should handle progress tracking with resume state on pushTasks', async () => {
      const { tileMergeTaskManager } = testContext;

      const jobId = randomUUID();

      // Set resume state
      mockInitTask.parameters.latestTaskState = {
        zoomLevel: 4,
        lastInsertedTaskIndex: 1,
      };

      const jobManagerBaseUrl = configMock.get<string>('jobManagement.config.jobManagerBaseUrl');
      const createTasksPath = `/jobs/${jobId}/tasks`;
      const updateTaskPath = `/jobs/${jobId}/tasks/${mockInitTask.id}`;

      nock(jobManagerBaseUrl).post(createTasksPath).reply(200).persist();
      nock(jobManagerBaseUrl).put(updateTaskPath).reply(200).persist();

      const updateTaskSpy = jest.spyOn(tileMergeTaskManager['queueClient'].jobManagerClient, 'updateTask');

      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);
      await tileMergeTaskManager.pushTasks(mockInitTask, jobId, ingestionNewJob.type, tasks);

      // Verify that progress tracking works even with resume state
      expect(updateTaskSpy).toHaveBeenCalled();

      updateTaskSpy.mockRestore();
    });

    it('should handle recovery when HTTP requests fail', async () => {
      const { tileMergeTaskManager } = testContext;

      const jobId = randomUUID();

      // Setup HTTP mocks to simulate failures
      const jobManagerBaseUrl = configMock.get<string>('jobManagement.config.jobManagerBaseUrl');
      const createTasksPath = `/jobs/${jobId}/tasks`;

      nock(jobManagerBaseUrl).post(createTasksPath).reply(500).persist();

      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);

      // Should reject when HTTP requests fail
      await expect(tileMergeTaskManager.pushTasks(mockInitTask, jobId, ingestionNewJob.type, tasks)).rejects.toThrow();
    });

    it('should handle ConflictError during batch publishing and stop immediately', async () => {
      const { tileMergeTaskManager } = testContext;

      const jobId = randomUUID();

      // Setup HTTP mock to return 409 Conflict
      const jobManagerBaseUrl = configMock.get<string>('jobManagement.config.jobManagerBaseUrl');
      const createTasksPath = `/jobs/${jobId}/tasks`;

      nock(jobManagerBaseUrl).post(createTasksPath).reply(409, { message: 'Job already aborted' }).persist();

      const tasks = tileMergeTaskManager.buildTasks(buildTasksParams, mockInitTask);

      // Spy on enqueueTasks to verify it's only called once (stops after conflict)
      const enqueueTasksSpy = jest.spyOn(tileMergeTaskManager as unknown as { enqueueTasks: jest.Func }, 'enqueueTasks');

      // Should throw ConflictError when job manager returns 409
      await expect(tileMergeTaskManager.pushTasks(mockInitTask, jobId, ingestionNewJob.type, tasks)).rejects.toThrow(ConflictError);

      // Verify that enqueueTasks was called (at least once before the conflict)
      expect(enqueueTasksSpy).toHaveBeenCalled();

      enqueueTasksSpy.mockRestore();
    });
  });
});