import {Component, computed, Signal} from '@angular/core';
import {MatAccordion} from '@angular/material/expansion';
import {TableData} from '@ghsc/nshmp-lib-ng/nshmp';
import {
  SourceType,
  sourceTypeToCapitalCase,
} from '@ghsc/nshmp-utils-ts/libs/nshmp-lib/model';
import {Parameter} from '@ghsc/nshmp-utils-ts/libs/nshmp-ws-utils/metadata';

import {
  ServiceResponse,
  ServiceResponses,
  Spectra,
} from '../../models/state.model';
import {AppService} from '../../services/app.service';
import {MathService} from '../../services/math.service';
import {SpectraPlotsService} from '../../services/spectra-plots.service';
import {TableDataPanelComponent} from '../table-data-panel/table-data-panel.component';

/**
 * Options for converting service response to table data.
 */
interface ServiceResponseToTableDataOptions extends ToTableDataOptions {
  /** A service response */
  serviceResponse: ServiceResponse;
}

/**
 * Options for converting service responses to table data.
 */
interface ServiceResponsesToTableDataOptions extends ToTableDataOptions {
  /** The service responses */
  serviceResponses: ServiceResponses;
}

/**
 * Options for converting to table data.
 */
interface ToTableDataOptions {
  /** Currently available models */
  availableModels: Parameter[];
  /** Function to return the name of the data */
  name: (modelInfo: Parameter, spectra: Spectra) => string;
  /** Return period value */
  returnPeriod: number;
  /** Function to filter the response spectra data */
  spectraFilter: (spectra: Spectra) => boolean;
}

/**
 * Component with tables for spectra data.
 */
@Component({
  imports: [MatAccordion, TableDataPanelComponent],
  selector: 'app-spectra-data',
  styleUrl: './spectra-data.component.scss',
  templateUrl: './spectra-data.component.html',
})
export class SpectraDataComponent {
  /** Model values */
  private models = `${this.service.formGroup.getRawValue().model}-${this.service.formGroup.getRawValue().modelCompare}`;

  /** Filename for hazard components export CSV */
  spectraComponentsFilename = `spectra-components-${this.models}.csv`;

  /** Filename for hazard difference export CSV */
  spectraDiffFilename = `spectra-%-diff-${this.models}.csv`;

  /** Filename for hazard export CSV */
  spectraFilename = `spectra-compare-${this.models}.csv`;

  /** Table data for response spectra components */
  spectraComponentsTableData = computed(() => {
    const serviceResponses = this.service.serviceResponses();

    if (serviceResponses.modelA === null || serviceResponses.modelB === null) {
      return [];
    }

    const imts = this.spectraImtRow(serviceResponses);

    const spectraFilter = (spectra: Spectra) =>
      spectra.sourceType !== SourceType.TOTAL;

    return [
      imts,
      ...this.serviceResponsesToTableData({
        availableModels: this.service.availableModels(),
        name: (modelInfo: Parameter, spectra: Spectra) =>
          `${modelInfo.display} - ${sourceTypeToCapitalCase(
            spectra.sourceType,
          )}`,
        returnPeriod: this.service.formGroup.getRawValue().returnPeriod,
        serviceResponses: this.service.serviceResponses(),
        spectraFilter,
      }),
    ];
  });

  /** Table data for response spectra difference */
  spectraDiffTableData: Signal<TableData[]> = computed(() => {
    const serviceResponses = this.service.serviceResponses();

    if (serviceResponses.modelA === null || serviceResponses.modelB === null) {
      return [];
    }

    const spectraDiff = this.spectraPlotsService.spectraPercentDifference(
      serviceResponses,
      this.service.formGroup.getRawValue().returnPeriod,
    );

    return [
      this.spectraImtRow(serviceResponses),
      {
        td: spectraDiff.percentDifference,
        th: 'Percent Difference',
      },
    ];
  });

  /** Table data for response spectra */
  spectraTotalTableData = computed(() => {
    const serviceResponses = this.service.serviceResponses();

    if (serviceResponses.modelA === null || serviceResponses.modelB === null) {
      return [];
    }

    const imts = this.spectraImtRow(serviceResponses);

    const spectraFilter = (spectra: Spectra) =>
      spectra.sourceType === SourceType.TOTAL;

    return [
      imts,
      ...this.serviceResponsesToTableData({
        availableModels: this.service.availableModels(),
        name: (modelInfo: Parameter) => modelInfo.display,
        returnPeriod: this.service.formGroup.getRawValue().returnPeriod,
        serviceResponses,
        spectraFilter,
      }),
    ];
  });

  constructor(
    private service: AppService,
    private mathService: MathService,
    private spectraPlotsService: SpectraPlotsService,
  ) {}

  /**
   * Returns the IMTs for the table.
   *
   * @param serviceResponses The service responses
   */
  spectraImtRow(serviceResponses: ServiceResponses): TableData {
    const spectraA = serviceResponses.modelA.spectra.find(
      spectra => spectra.sourceType === SourceType.TOTAL,
    );
    const spectraB = serviceResponses.modelB.spectra.find(
      spectra => spectra.sourceType === SourceType.TOTAL,
    );

    const imtsA = spectraA.responseSpectra.imts;
    const imtsB = spectraB.responseSpectra.imts;

    return {
      td: imtsA.length >= imtsB.length ? imtsA : imtsB,
      th: 'IMT',
    };
  }

  /**
   * Convert a service response to table data.
   *
   * @param options The options
   */
  serviceResponseToTableData(
    options: ServiceResponseToTableDataOptions,
  ): TableData[] {
    return options.serviceResponse.spectra
      .filter(options.spectraFilter)
      .map(spectra => {
        const returnPeriodSpectra =
          spectra.responseSpectra.responseSpectrum.find(
            spectrum => spectrum.returnPeriod === options.returnPeriod,
          );

        const modelInfo = this.mathService.getModelInfo(
          options.serviceResponse.model,
          options.availableModels,
        );

        return {
          td: returnPeriodSpectra.values,
          th: options.name(modelInfo, spectra),
        };
      });
  }

  /**
   * Convert service responses to table data.
   *
   * @param options The options
   */
  serviceResponsesToTableData(options: ServiceResponsesToTableDataOptions) {
    return [
      ...this.serviceResponseToTableData({
        ...options,
        serviceResponse: options.serviceResponses.modelA,
      }),
      ...this.serviceResponseToTableData({
        ...options,
        serviceResponse: options.serviceResponses.modelB,
      }),
    ];
  }
}