import {Component, computed, DestroyRef, inject, OnInit, Signal} from '@angular/core';
import {takeUntilDestroyed} from '@angular/core/rxjs-interop';
import {ReactiveFormsModule} from '@angular/forms';
import {MatError, MatFormField, MatLabel} from '@angular/material/form-field';
import {MatInput} from '@angular/material/input';
import {MatRadioButton, MatRadioGroup} from '@angular/material/radio';
import {
  DisaggTarget,
  HazardService,
  NshmpHazardImtFormComponent,
  NshmpHazardLocationFormComponent,
  NshmpHazardMaxDirectionFormComponent,
  NshmpHazardModelFormComponent,
  NshmpHazardModelInfoComponent,
  NshmpHazardReturnPeriodFormComponent,
  NshmpHazardSiteClassFormComponent,
} from '@ghsc/nshmp-lib/hazard';
import {NshmpMapSelectSiteComponent, SelectSiteDialogData} from '@ghsc/nshmp-lib/map';
import {NshmpControlPanelButtonsComponent, NshmpService} from '@ghsc/nshmp-lib/nshmp';
import {Location} from '@ghsc/nshmp-utils-ts/libs/nshmp-lib/geo';
import {environment} from '@nshmp-apps/environments/environment';
import {combineLatest} from 'rxjs';

import {AppService} from '../../services/app.service';

/**
 * Control panel with form fields to call disagg service.
 *
 * Handles disagg service with return period and imt.
 */
@Component({
  host: {id: 'hazard-disagg-control-panel'},
  imports: [
    MatError,
    MatFormField,
    MatInput,
    MatLabel,
    MatRadioButton,
    MatRadioGroup,
    NshmpControlPanelButtonsComponent,
    NshmpControlPanelButtonsComponent,
    NshmpHazardImtFormComponent,
    NshmpHazardLocationFormComponent,
    NshmpHazardMaxDirectionFormComponent,
    NshmpHazardModelFormComponent,
    NshmpHazardModelInfoComponent,
    NshmpHazardReturnPeriodFormComponent,
    NshmpHazardSiteClassFormComponent,
    NshmpMapSelectSiteComponent,
    ReactiveFormsModule,
  ],
  selector: 'app-control-panel',
  styleUrl: './control-panel.component.scss',
  templateUrl: './control-panel.component.html',
})
export class ControlPanelComponent implements OnInit {
  service = inject(AppService);
  private destroyRef = inject(DestroyRef);
  private hazardService = inject(HazardService);
  private nshmpService = inject(NshmpService);

  /** Disaggregation target enum */
  DisaggTarget = DisaggTarget;

  /** Form fields state */
  form = this.service.formGroup;

  /** IML range from usage, based on IMT value */
  imlRange = computed(() => {
    const usage = this.service.usage();

    if (usage) {
      return usage.response.iml.range[this.form.getRawValue().imt];
    }
  });

  /** Data for select site component */
  selectSiteData: Signal<SelectSiteDialogData> = computed(() => {
    const metadata = this.service.metadata();

    if (metadata === undefined) {
      return {
        mapUrl: '',
      };
    }

    const services = environment.webServices.nshmpHazWs.services.curveServices;

    return this.hazardService.metadataToSiteData(metadata, {
      faultSections: services.features,
      map: services.map,
      testSites: services.sites,
    });
  });

  /** Service call info state */
  serviceCallInfo = this.service.serviceCallInfo;

  imts = computed(() => this.service.usage()?.response.model.imts);

  /** The site classes */
  siteClasses = computed(() => this.service.usage()?.response.model.siteClasses);

  /** Source model info from usage */
  sourceModel = computed(() => this.service.usage()?.response?.model);

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

    controls.disaggTarget.valueChanges.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
      this.service.onDisaggTarget();
      this.service.resetState();
    });

    controls.model.valueChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => this.onModelChange());

    combineLatest([controls.latitude.valueChanges, controls.longitude.valueChanges])
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => {
        this.service.resetState();
        const values = this.form.getRawValue();

        if (values.latitude && values.longitude) {
          this.selectSiteData().site = {
            latitude: values.latitude,
            longitude: values.longitude,
          };
        }
      });

    combineLatest([
      controls.iml.valueChanges,
      controls.imt.valueChanges,
      controls.returnPeriod.valueChanges,
      controls.vs30.valueChanges,
    ])
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe(() => {
        this.service.resetState();
      });
  }

  /**
   * On form submit.
   */
  onSubmit(): void {
    this.service.callService();
    this.nshmpService.selectPlotControl();
  }

  setLocation(location: Location): void {
    this.form.patchValue({
      latitude: location.latitude,
      longitude: location.longitude,
    });
  }

  private onModelChange(): void {
    const {latitude, longitude} = this.form.getRawValue();
    const latitudeBounds = this.service.usage()?.response.latitude;
    const longitudeBounds = this.service.usage()?.response.longitude;

    if (
      latitudeBounds &&
      longitudeBounds &&
      !(
        latitude >= latitudeBounds.min &&
        latitude <= latitudeBounds.max &&
        longitude >= longitudeBounds.min &&
        longitude <= longitudeBounds.max
      )
    ) {
      this.form.patchValue({
        latitude: NaN,
        longitude: NaN,
      });
    }

    this.form.controls.latitude.markAsPristine();
    this.form.controls.longitude.markAsPristine();
    this.service.resetState();
  }
}