import type {
  IExecuteFunctions,
  ILoadOptionsFunctions,
  INodeExecutionData,
  INodeType,
  INodeTypeDescription,
} from 'n8n-workflow';
import { NodeConnectionTypes, NodeOperationError } from 'n8n-workflow';

import {
  DATA_PRODUCT_BASE_PATH,
  DATA_PRODUCT_READER_CATALOG_PATH,
  DATA_PRODUCT_SNAPSHOT_SUFFIX,
  DATA_PLANE_DEFAULT_BASE_URL,
  DATA_PLANE_BASE_URL_ENV,
  NDC_DATA_PRODUCT_READER_CREDENTIAL,
  NDC_NODE_ICON,
} from '../shared/constants';
import { normalizeSnapshotFacts, snapshotReadParameters } from '../shared/contracts';
import { safeHttpError, safeInputError } from '../shared/errors';
import { loadDataProductOptions, ndcRequest, serviceBaseUrl } from '../shared/http';

export class NdcDataProductRead implements INodeType {
  description: INodeTypeDescription = {
    displayName: 'NDC Data Product Read',
    name: 'ndcDataProductRead',
    icon: NDC_NODE_ICON,
    group: ['input'],
    version: 1,
    subtitle: '={{$parameter["dataProductId"]}}',
    description: 'Read a scoped NDC Data Product snapshot',
    defaults: { name: 'NDC Data Product Read' },
    inputs: [NodeConnectionTypes.Main],
    outputs: [NodeConnectionTypes.Main],
    credentials: [{ name: NDC_DATA_PRODUCT_READER_CREDENTIAL, required: true }],
    properties: [
      {
        displayName: 'Data Product Name or ID',
        name: 'dataProductId',
        type: 'options',
        typeOptions: { loadOptionsMethod: 'getDataProducts' },
        default: '',
        required: true,
      },
      {
        displayName: 'Page Size',
        name: 'pageSize',
        type: 'number',
        typeOptions: { minValue: 1, maxValue: 5000, numberStepSize: 1 },
        default: 1000,
        required: true,
        description: 'Maximum number of snapshot facts to return',
      },
    ],
  };

  methods = {
    loadOptions: {
      async getDataProducts(this: ILoadOptionsFunctions) {
        return loadDataProductOptions(
          this,
          NDC_DATA_PRODUCT_READER_CREDENTIAL,
          DATA_PLANE_BASE_URL_ENV,
          DATA_PLANE_DEFAULT_BASE_URL,
          DATA_PRODUCT_READER_CATALOG_PATH,
        );
      },
    },
  };

  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
    const dataProductId = this.getNodeParameter('dataProductId', 0) as string;
    const pageSize = this.getNodeParameter('pageSize', 0, 1000) as number;
    let parameters;
    try {
      parameters = snapshotReadParameters(dataProductId, pageSize);
    } catch (error) {
      throw new NodeOperationError(this.getNode(), safeInputError(error, 'ndc_data_product_read_input_invalid'));
    }

    try {
      const baseUrl = serviceBaseUrl(DATA_PLANE_BASE_URL_ENV, DATA_PLANE_DEFAULT_BASE_URL);
      const response = await ndcRequest(this, NDC_DATA_PRODUCT_READER_CREDENTIAL, {
        method: 'GET',
        url: `${baseUrl}${DATA_PRODUCT_BASE_PATH}/${parameters.encodedProductId}${DATA_PRODUCT_SNAPSHOT_SUFFIX}`,
        qs: {
          limit: parameters.pageSize,
        },
      });
      const facts = normalizeSnapshotFacts(response);
      return [facts.map((fact) => ({ json: fact, pairedItem: { item: 0 } }))];
    } catch (error) {
      const safe = error instanceof Error && error.message === 'data_product_snapshot_invalid'
        ? safeInputError(error, 'ndc_data_product_snapshot_invalid')
        : safeHttpError(error, 'ndc_data_product_read_failed');
      throw new NodeOperationError(this.getNode(), safe);
    }
  }
}