/**
 * Copyright IBM Corp. 2024, 2025
 */
import path from 'path';
import fs from 'fs';
import JSZip from 'jszip';
import * as yaml from 'js-yaml';

jest.mock('@apic/studio-shared', () => ({
  Component: {
    Build: 'Build',
  },

  LogComponent: () => {
    return () => {
      /* noop */
    };
  },

  isValidAsset: jest.fn().mockReturnValue(true),

  Logger: {
    error: jest.fn(),
    warn: jest.fn(),
    info: jest.fn(),
    debug: jest.fn(),
  },

  toError: jest.fn((e) => (e instanceof Error ? e : new Error(String(e)))),

  ErrorResponse: jest.fn(),
  Metadata_Ref: jest.fn(),
  SpecObject: jest.fn(),
  YamlContent: jest.fn(),
  UpperCaseKinds: jest.fn(),
  loadYaml: jest.fn((content) => require('js-yaml').load(content)),

  SchemaHandler: jest.fn().mockImplementation(() => ({
    getSchema: jest.fn().mockReturnValue(JSON.stringify({ type: 'object' })),
  })),
}));

jest.mock('@apic/studio-client-model', () => ({
  AssetModelKindConstants: {
    API: 'API',
  },
}));

import { ProjectAssetValidator } from '../src/validator/asset-validator.js';
import { BuildProjectAssets } from '../src/build-project-assets.js';
import {
  normalizeZipPaths,
  ReferenceValidationResultMap,
  resolveRelativePaths,
} from '../src/index.js';
import { DataPowerAdapter } from '../src/adapter/datapower-adapter.js';

describe('Build Asset Project Modules', () => {
  let validationResult: ReferenceValidationResultMap;
  let consoleSpy: jest.SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
  beforeEach(() => {
    consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
  });

  afterEach(() => {
    consoleSpy.mockRestore();
  });
  it('should process the zip and return zip content ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    const result = await obj['loadZipFromBuffer'](Buffer);
    expect(result).not.toBe(null);
    expect(result).not.toBe(undefined);
    expect(result).not.toBe(false);
  });

  it('should validate the zip and return true ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-multi-project-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const zip2 = await JSZip.loadAsync(Buffer);
    const normalizedBuffer = await normalizeZipPaths(zip2);
    const zip3 = await resolveRelativePaths(
      await normalizedBuffer.generateAsync({ type: 'nodebuffer' })
    );
    const buffer2 = await zip3.generateAsync({ type: 'nodebuffer' });
    const obj = new BuildProjectAssets();
    const result = await obj['validate'](buffer2);
    validationResult = result;
    expect(result).not.toBe(null);
    expect(result).not.toBe(undefined);
    expect(result.isValid).toBe(true);
    expect(result.isValid).not.toBe(false);
    expect(result.allRefMaps).not.toBe(null);
    expect(result.allRefMaps).not.toBe(undefined);
    const allRefMaps = result.allRefMaps;
    expect(allRefMaps.size).toBeGreaterThan(0);
    allRefMaps.forEach((refMap, folderName) => {
      expect(refMap).toBeInstanceOf(Map);
      expect(folderName).toBeDefined();
      expect(folderName).not.toBe('');
    });
  });

  it('should extract foldername and filepaths in folder ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-multi-project-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    const folderNames = new Set<string>();
    const filePathsInFolder = new Set<string>();
    await obj['extractFolderNamesAndPaths'](Buffer, folderNames, filePathsInFolder);
    expect(folderNames.size).not.toBeLessThan(1);
    expect(filePathsInFolder.size).not.toBeLessThan(1);
  });

  it('should run all the asset validator function and return true ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-multi-project-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const zip2 = await JSZip.loadAsync(Buffer);
    const normalizedBuffer = await normalizeZipPaths(zip2);
    const zip3 = await resolveRelativePaths(
      await normalizedBuffer.generateAsync({ type: 'nodebuffer' })
    );
    const buffer2 = await zip3.generateAsync({ type: 'nodebuffer' });
    const obj = new BuildProjectAssets();
    const folderNames = new Set<string>();
    const filePathsInFolder = new Set<string>();
    await obj['extractFolderNamesAndPaths'](buffer2, folderNames, filePathsInFolder);
    const asset = new ProjectAssetValidator();
    const result = await obj['validateFolder'](
      buffer2,
      'demo',
      asset,
      filePathsInFolder,
      folderNames
    );
    console.log(result);
    expect(result.isValid).toBe(true);
  });

  it('should get the file if it is present in the zip else return null ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-multi-project-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    const result = await obj['getFileFromZip'](Buffer, 'demo/petstore.yml');
    expect(result).not.toBe(null);
    const result2 = await obj['getFileFromZip'](Buffer, 'project22/petstore.yaml');
    expect(result2).toBe(null);
  });

  it('should create the zip that is passed to gateway  ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-multi-project-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const zip2 = await JSZip.loadAsync(Buffer);
    const normalizedBuffer = await normalizeZipPaths(zip2);
    const zip3 = await resolveRelativePaths(
      await normalizedBuffer.generateAsync({ type: 'nodebuffer' })
    );
    const buffer2 = await zip3.generateAsync({ type: 'nodebuffer' });
    const obj = new BuildProjectAssets();
    const validation = await obj['validate'](buffer2);
    const result = await obj['createProjectBuildZip'](buffer2, validation.allRefMaps, 'apim');
    expect(result).not.toBe(null);
    expect(result).not.toBe(undefined);
    expect(result).not.toBe(false);
  });

  it('should create a consolidated yaml and add to the zip that is build ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-multi-project-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const zip2 = await JSZip.loadAsync(Buffer);
    const normalizedBuffer = await normalizeZipPaths(zip2);
    const zip3 = await resolveRelativePaths(
      await normalizedBuffer.generateAsync({ type: 'nodebuffer' })
    );
    const buffer2 = await zip3.generateAsync({ type: 'nodebuffer' });
    const obj = new BuildProjectAssets();
    const validation = await obj['validate'](buffer2);
    const folderNames = new Set<string>();
    const filePathsInFolder = new Set<string>();
    await obj['extractFolderNamesAndPaths'](buffer2, folderNames, filePathsInFolder);
    const zip = new JSZip();
    await obj['addConsolidatedYAMLs'](zip, buffer2, folderNames, validation.allRefMaps);
    const files = Object.keys(zip.files);
    expect(files.length).toBeGreaterThan(0);
  });

  it('should check for datapower asset ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/datapower-gateway-jsonspec.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    let specToContentMap = new Map<string, string>();
    specToContentMap = await obj['adaptToDataPower'](Buffer, specToContentMap);
    expect(specToContentMap.size).toBeGreaterThan(0);
  });

  it('should add the non asset file to the resource folder  ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-multi-project-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    const zip2 = await JSZip.loadAsync(Buffer);
    const normalizedBuffer = await normalizeZipPaths(zip2);
    const zip3 = await resolveRelativePaths(
      await normalizedBuffer.generateAsync({ type: 'nodebuffer' })
    );
    const folderNames = new Set<string>();
    const filePathsInFolder = new Set<string>();
    const buffer2 = await zip3.generateAsync({ type: 'nodebuffer' });
    await obj['extractFolderNamesAndPaths'](buffer2, folderNames, filePathsInFolder);
    const zip = new JSZip();
    await obj['addReferencedFiles'](zip, buffer2, folderNames, new Map(), 'apim');

    const files = Object.keys(zip.files);
    expect(files.length).toBeGreaterThan(0);
  });

  it('should add the datapower asset file to the spec file in the resource folder with json spec ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/datapower-gateway-jsonspec.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    const zip2 = await JSZip.loadAsync(Buffer);
    const normalizedBuffer = await normalizeZipPaths(zip2);
    const zip3 = await resolveRelativePaths(
      await normalizedBuffer.generateAsync({ type: 'nodebuffer' })
    );
    const folderNames = new Set<string>();
    const filePathsInFolder = new Set<string>();
    const buffer2 = await zip3.generateAsync({ type: 'nodebuffer' });
    await obj['extractFolderNamesAndPaths'](buffer2, folderNames, filePathsInFolder);
    const zip = new JSZip();
    let specToContentMap = new Map<string, string>();
    const adapter = new DataPowerAdapter();
    specToContentMap = await adapter.getDataPowerAssemblyContent(buffer2);
    await obj['addReferencedFiles'](zip, buffer2, folderNames, specToContentMap, 'apim');

    let datapower = false;
    const files = Object.keys(zip.files);
    for (const fileName in zip.files) {
      const entry = zip.files[fileName];
      specToContentMap.keys();
      if (!entry.dir) {
        const content = await entry.async('string');
        if (content.includes('x-ibm-configuration')) {
          datapower = true;
        }
      }
    }
    expect(files.length).toBeGreaterThan(0);
    expect(datapower).toBe(true);
  });

  it('should add the x-ibm-name for non datapower asset to the spec file in the resource folder with json spec', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/non-datapower-gateway-jsonspec.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    const zip2 = await JSZip.loadAsync(Buffer);
    const normalizedBuffer = await normalizeZipPaths(zip2);
    const zip3 = await resolveRelativePaths(
      await normalizedBuffer.generateAsync({ type: 'nodebuffer' })
    );
    const folderNames = new Set<string>();
    const filePathsInFolder = new Set<string>();
    const buffer2 = await zip3.generateAsync({ type: 'nodebuffer' });
    await obj['extractFolderNamesAndPaths'](buffer2, folderNames, filePathsInFolder);
    const zip = new JSZip();
    let specToContentMap = new Map<string, string>();
    await obj['addReferencedFiles'](zip, buffer2, folderNames, specToContentMap, 'apim');

    let datapower = false;
    const files = Object.keys(zip.files);
    for (const fileName in zip.files) {
      const entry = zip.files[fileName];
      specToContentMap.keys();
      if (!entry.dir) {
        const content = await entry.async('string');
        if (content.includes('x-ibm-configuration')) {
          datapower = true;
        } else {
          datapower = false;
        }
      }
    }
    expect(files.length).toBeGreaterThan(0);
    expect(datapower).toBe(false);
  });

  it('should add the datapower asset file to the spec file in the resource folder with yaml spec ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/datapower-gateway-yamlspec.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    const zip2 = await JSZip.loadAsync(Buffer);
    const normalizedBuffer = await normalizeZipPaths(zip2);
    const zip3 = await resolveRelativePaths(
      await normalizedBuffer.generateAsync({ type: 'nodebuffer' })
    );
    const folderNames = new Set<string>();
    const filePathsInFolder = new Set<string>();
    const buffer2 = await zip3.generateAsync({ type: 'nodebuffer' });
    await obj['extractFolderNamesAndPaths'](buffer2, folderNames, filePathsInFolder);
    const zip = new JSZip();
    let specToContentMap = new Map<string, string>();
    const adapter = new DataPowerAdapter();
    specToContentMap = await adapter.getDataPowerAssemblyContent(buffer2);
    await obj['addReferencedFiles'](zip, buffer2, folderNames, specToContentMap, 'apim');

    let datapower = false;
    const files = Object.keys(zip.files);
    for (const fileName in zip.files) {
      const entry = zip.files[fileName];
      specToContentMap.keys();
      if (!entry.dir) {
        const content = await entry.async('string');
        if (content.includes('x-ibm-configuration')) {
          datapower = true;
        }
      }
    }
    expect(files.length).toBeGreaterThan(0);
    expect(datapower).toBe(true);
  });

  it('should create consolidated yaml for specific project ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-multi-project-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    const zip2 = await JSZip.loadAsync(Buffer);
    const normalizedBuffer = await normalizeZipPaths(zip2);
    const buffer2 = await normalizedBuffer.generateAsync({
      type: 'nodebuffer',
    });
    let result = '';
    result = await obj['createConsolidatedYaml'](buffer2, 'project1', validationResult.allRefMaps);
    expect(result).not.toBe('');
    expect(result.length).toBeGreaterThan(0);
  });

  it('should process the project zip and return the build zip ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-multi-project-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    const zip2 = await JSZip.loadAsync(Buffer);
    const normalizedBuffer = await normalizeZipPaths(zip2);
    const zip3 = await resolveRelativePaths(
      await normalizedBuffer.generateAsync({ type: 'nodebuffer' })
    );
    const buffer2 = await zip3.generateAsync({ type: 'nodebuffer' });
    const result = await obj.processProjectZip(buffer2, 'apim');
    expect(result).not.toBe(undefined);
    //commented next expect because the zip creation did not happen as the zip is missing a product kind file
    // expect(result?.zip?.files['project1.yaml'].name).toBe('project1.yaml');
  });

  it('should process the project zip and return Gateway json ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-multi-project-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    const result = await obj.extractGatewaysJson(Buffer);
    expect(result).not.toBe(undefined);
    expect(result).not.toBe(null);
    expect(result.gateways.length).toBeGreaterThan(0);
  });

  it('should create consolidated yaml for dependencies within project ', async () => {
    const zipFilePath = path.resolve(__dirname, './assets/gateway-projects-dependent-asset.zip');
    const Buffer = fs.readFileSync(zipFilePath);
    const obj = new BuildProjectAssets();
    const zip2 = await JSZip.loadAsync(Buffer);
    const normalizedBuffer = await normalizeZipPaths(zip2);
    const buffer2 = await normalizedBuffer.generateAsync({
      type: 'nodebuffer',
    });
    let result = '';
    const allRefMaps = new Map<string, Map<string, boolean>>([
      [
        'project1',
        new Map([
          ['dev:SwaggerrAPI:1.0', true],
          ['dev:dev_policies:1.0', true],
          ['dev:default_endpoint:1.0', true],
        ]),
      ],
      ['project2', new Map([['dev:dev_policies:1.0', true]])],
    ]);
    result = await obj['createConsolidatedYaml'](buffer2, 'project1', allRefMaps);
    expect(result).not.toBe('');
    expect(result.length).toBeGreaterThan(0);
  });

  it('should return matching API metadata when spec file matches $path', async () => {
    const zip = new JSZip();
    const specFileName = 'apis/test-api.yaml';
    const apiMetadata = {
      kind: 'API',
      spec: {
        'api-spec': {
          $path: specFileName,
        },
      },
      metadata: {
        namespace: 'test-namespace',
        name: 'test-name',
        version: '1.0.0',
      },
    };

    zip.file('metadata/api.yaml', yaml.dump(apiMetadata));
    const buffer = await zip.generateAsync({ type: 'nodebuffer' });
    const obj = new BuildProjectAssets();
    const result = await obj['findMatchingApiMetadataForSpecFile'](buffer, specFileName);
    expect(result).toEqual({
      namespace: 'test-namespace',
      name: 'test-name',
      version: '1.0.0',
    });
  });

  it('should handle YAML parsing errors and continue processing (catch block coverage)', async () => {
    const zip = new JSZip();
    const specFileName = 'apis/test-api.yaml';

    // Add a file with invalid YAML content
    zip.file(
      'metadata/bad-api.yaml',
      `
      kind: API
      spec:
        api-spec:
          $path: "apis/test-api.yaml
      metadata:
        namespace: testns
        name: testname
        version: 1.0.0
    `
    ); // Missing closing quote and invalid indentation

    const buffer = await zip.generateAsync({ type: 'nodebuffer' });
    const obj = new BuildProjectAssets();
    const result = await obj['findMatchingApiMetadataForSpecFile'](buffer, specFileName);
    expect(result).toBeNull();
  });
});