import {Component, DestroyRef, OnInit} from '@angular/core';
import {takeUntilDestroyed} from '@angular/core/rxjs-interop';
import {ReactiveFormsModule} from '@angular/forms';
import {MatOption} from '@angular/material/core';
import {MatFormField, MatLabel} from '@angular/material/form-field';
import {MatIconModule} from '@angular/material/icon';
import {MatSelect, MatSelectModule} from '@angular/material/select';
import {MatSlideToggle} from '@angular/material/slide-toggle';
import {MatSliderModule} from '@angular/material/slider';
import Layer from '@arcgis/core/layers/Layer';
import {NshmpHazardModelFormComponent} from '@ghsc/nshmp-lib-ng/hazard';
import {NshmpSectionComponent, ReturnPeriod} from '@ghsc/nshmp-lib-ng/nshmp';
import {FeatureType} from '@ghsc/nshmp-utils-ts/libs/nshmp-haz/www/features-service';
import {Imt} from '@ghsc/nshmp-utils-ts/libs/nshmp-lib/gmm';
import {nshmYear} from '@ghsc/nshmp-utils-ts/libs/nshmp-lib/nshm';

import {LatestEarthquakeTime} from '../../models/control-form.model';
import {AppService} from '../../services/app.service';

/**
 * Form fields for turning on and off different map layers.
 */
@Component({
  imports: [
    NshmpHazardModelFormComponent,
    MatLabel,
    MatSlideToggle,
    MatFormField,
    MatSelect,
    MatOption,
    ReactiveFormsModule,
    MatIconModule,
    MatSelectModule,
    MatSliderModule,
    NshmpSectionComponent,
  ],
  selector: 'app-control-panel',
  styleUrl: './control-panel.component.scss',
  templateUrl: './control-panel.component.html',
})
export class ControlPanelComponent implements OnInit {
  /** Earthquake feature type */
  FeatureType = FeatureType;
  LatestEarthquakeTime = LatestEarthquakeTime;

  /** Form field state */
  formGroup = this.service.formGroup;

  /** Available IMTs for hazard map tiles */
  imts: Set<Imt> = new Set();

  /** Available return periods for hazard map tiles */
  returnPeriods: Set<ReturnPeriod> = new Set();

  /** Available years for hazard map tiles */
  years: Set<number> = new Set();

  constructor(
    public service: AppService,
    private destroyRef: DestroyRef,
  ) {}

  ngOnInit(): void {
    const controls = this.formGroup.controls;

    controls.model.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => this.onModelChange());
    controls.hasNshmBoundaryLayer.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => this.onNshmBoundaryToggle());
    controls.hazardTileImt.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => this.service.createHazardLayer());
    controls.hazardTileReturnPeriod.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => this.service.createHazardLayer());
    controls.hazardTileYear.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => this.onHazardTileYear());
    controls.hasHazardTiles.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => this.onHazardToggle());
    controls.overlayOpacity.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => this.service.createHazardLayer());
    controls.latestEarthquakeTime.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => this.service.callEarthquakesService());
    controls.hasTestSitesLayer.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => this.onTestSitesToggle());
    controls.hasDecollementLayer.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(checked => this.onFeaturesToggle(checked, FeatureType.DECOLLEMENT));
    controls.hasFaultSectionLayer.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(checked => this.onFeaturesToggle(checked, FeatureType.FAULT));
    controls.hasInterfaceSectionsLayer.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(checked => this.onFeaturesToggle(checked, FeatureType.INTERFACE));
    controls.hasZoneSourcesLayer.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(checked => this.onFeaturesToggle(checked, FeatureType.ZONE));
    controls.hasEarthquakesLayer.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => this.onEartquakesToggle());

    controls.hasTracesOnlyFaultSections.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() =>
        this.onFeaturePolygonToggle(
          this.formGroup.getRawValue().hasFaultSectionLayer,
          FeatureType.FAULT,
        ),
      );

    controls.hasTracesOnlyInterfaceSections.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() =>
        this.onFeaturePolygonToggle(
          this.formGroup.getRawValue().hasInterfaceSectionsLayer,
          FeatureType.INTERFACE,
        ),
      );
  }

  private onEartquakesToggle(): void {
    const layer = this.service.layers().earthquakesLayer;
    this.service.callEarthquakesService(layer);
  }

  private onFeaturePolygonToggle(checked: boolean, featureType: FeatureType): void {
    this.service.callFeaturesService(featureType, undefined, checked);
  }

  /**
   * Call features service when toggled.
   *
   * @param checked Whether toggle is checked
   * @param featureType The feature type
   */
  private onFeaturesToggle(checked: boolean, featureType: FeatureType): void {
    switch (featureType) {
      case FeatureType.FAULT: {
        const control = this.formGroup.controls.hasTracesOnlyFaultSections;
        if (checked) {
          control.enable();
        } else {
          control.disable();
        }
        break;
      }
      case FeatureType.INTERFACE: {
        const control = this.formGroup.controls.hasTracesOnlyInterfaceSections;
        if (checked) {
          control.enable();
        } else {
          control.disable();
        }
        break;
      }
      default: {
        const layers = Object.values(this.service.layers()) as Layer[];
        const layer = layers.find(layer => layer?.id === featureType.toString());
        this.service.callFeaturesService(featureType, layer, checked);
      }
    }
  }

  private onHazardTileYear(): void {
    this.imts = new Set(
      this.service
        .filterTilesByYear(this.service.hazardTiles(), this.formGroup.getRawValue())
        .map(tile => tile.imt),
    );
    this.returnPeriods = new Set(
      this.service
        .filterTilesByImt(this.service.hazardTiles(), this.formGroup.getRawValue())
        .map(tile => tile.returnPeriod),
    );

    this.service.createHazardLayer();
  }

  private onHazardToggle(): void {
    const layer = this.service.layers().hazardLayer;
    this.service.createHazardLayer(layer);
  }

  private onModelChange(): void {
    this.years = new Set(
      this.service
        .filterTilesByRegion(this.service.hazardTiles(), this.formGroup.getRawValue())
        .map(tile => nshmYear(tile.nshm)),
    );
    this.service.resetState();
  }

  /**
   * Call map service when toggled.
   *
   * @param checked Wether toggle is checked
   */
  private onNshmBoundaryToggle(): void {
    const layers = this.service.layers();
    this.service.callService(layers.nshmBoundaryLayer);
  }

  /**
   * Call test sites service when toggled.
   * @param checked Whether toggle is checked
   */
  private onTestSitesToggle(): void {
    const layer = this.service.layers().testSitesLayer;
    this.service.callTestSitesService(layer);
  }
}