import {
  Component,
  ViewChild,
  inject,
  ChangeDetectionStrategy,
  signal,
  computed,
} from "@angular/core";
import { ParsedData } from "../../common-components/parsed-file-input/parsed-file-input.component";
import { MatStepper, MatStepperModule } from "@angular/material/stepper";
import { ColumnMapping } from "../column-mapping";
import { ImportFileComponent } from "../import-file/import-file.component";
import { ConfirmationDialogService } from "../../common-components/confirmation-dialog/confirmation-dialog.service";
import { ImportMetadata, ImportSettings } from "../import-metadata";
import { AlertService } from "../../alerts/alert.service";
import { ActivatedRoute, Router } from "@angular/router";
import { FontAwesomeModule } from "@fortawesome/angular-fontawesome";
import { MatCardModule } from "@angular/material/card";
import { ImportHistoryComponent } from "../import-history/import-history.component";
import { EntityTypeLabelPipe } from "../../common-components/entity-type-label/entity-type-label.pipe";
import { ImportEntityTypeComponent } from "../import-entity-type/import-entity-type.component";
import { MatExpansionModule } from "@angular/material/expansion";
import { ImportAdditionalActionsComponent } from "../additional-actions/import-additional/import-additional-actions.component";
import { MatButtonModule } from "@angular/material/button";
import { ImportColumnMappingComponent } from "../import-column-mapping/import-column-mapping.component";
import { ImportReviewDataComponent } from "../import-review-data/import-review-data.component";
import { LOCATION_TOKEN } from "../../../utils/di-tokens";
import { RouteTarget } from "../../../route-target";
import { ImportMatchExistingComponent } from "../update-existing/import-match-existing/import-match-existing.component";
import { WarningNotOptimizedForSmallScreenComponent } from "#src/app/core/common-components/warning-not-optimized-for-small-screen/warning-not-optimized-for-small-screen.component";
import { EntityAbility } from "../../permissions/ability/entity-ability";
import { HintBoxComponent } from "../../common-components/hint-box/hint-box.component";
import { EntityRegistry } from "../../entity/database-entity.decorator";
import { ImportConfigDialogService } from "../import-column-mapping/import-config-dialog.service";

/**
 * View providing a full UI workflow to import data from an uploaded file.
 */
@RouteTarget("Import")
@Component({
  changeDetection: ChangeDetectionStrategy.OnPush,
  selector: "app-import",
  templateUrl: "./import.component.html",
  styleUrls: ["./import.component.scss"],
  imports: [
    MatStepperModule,
    FontAwesomeModule,
    ImportFileComponent,
    MatCardModule,
    ImportHistoryComponent,
    EntityTypeLabelPipe,
    ImportEntityTypeComponent,
    MatExpansionModule,
    ImportAdditionalActionsComponent,
    ImportMatchExistingComponent,
    MatButtonModule,
    ImportColumnMappingComponent,
    ImportReviewDataComponent,
    WarningNotOptimizedForSmallScreenComponent,
    HintBoxComponent,
  ],
})
export class ImportComponent {
  private confirmationDialog = inject(ConfirmationDialogService);
  private alertService = inject(AlertService);
  private route = inject(ActivatedRoute);
  private router = inject(Router);
  private location = inject<Location>(LOCATION_TOKEN);
  private readonly ability = inject(EntityAbility);
  private readonly entities = inject(EntityRegistry);
  private readonly configDialogs = inject(ImportConfigDialogService);

  rawData: any[];

  importSettings = signal<Partial<ImportSettings>>({});

  /**
   * Whether the current user lacks permission to create ImportMetadata records.
   * Every import writes an ImportMetadata history entry at the end, so without this
   * permission no import can succeed - block the whole flow up front rather than
   * letting the user prepare an import that would fail.
   */
  cannotImport =
    this.ability.initialized && this.ability.cannot("create", ImportMetadata);

  /**
   * Whether the user may update existing records of the selected type.
   * The "check/update existing" option modifies existing records, so it requires
   * update (not just create) permission on the target type.
   */
  canUpdateSelectedType = computed(() => {
    const entityType = this.importSettings().entityType;
    return (
      !!entityType &&
      (!this.ability.initialized || this.ability.can("update", entityType))
    );
  });

  /**
   * Whether the selected type cannot be created by the user.
   * The dropdown already hides non-creatable types, but a type can also arrive
   * via the entityType query parameter (e.g. a bookmarked link), so guard the
   * selection here too instead of only failing at the final save.
   */
  cannotCreateSelectedType = computed(() => {
    const entityType = this.importSettings().entityType;
    return (
      !!entityType &&
      this.ability.initialized &&
      this.ability.cannot("create", entityType)
    );
  });

  @ViewChild(MatStepper) stepper: MatStepper;
  @ViewChild(ImportFileComponent) importFileComponent: ImportFileComponent;

  /** calculated for validation on columnMapping changes */
  mappedColumnsCount = computed(
    () =>
      this.importSettings().columnMapping?.filter((m) => !!m.propertyName)
        .length ?? 0,
  );

  /**
   * Columns that are mapped to a field whose values have to be transformed,
   * but whose transformation the user has not configured and confirmed yet.
   */
  columnsMissingConfig = computed(() => {
    const entityType = this.importSettings().entityType;
    const entityCtor = entityType ? this.entities.get(entityType) : undefined;
    if (!entityCtor) {
      return [];
    }
    return (this.importSettings().columnMapping ?? []).filter((m) =>
      this.configDialogs.isConfigMissing(m, entityCtor),
    );
  });

  /** whether the user can continue from the column mapping step to the import preview */
  columnMappingComplete = computed(
    () =>
      this.mappedColumnsCount() > 0 && this.columnsMissingConfig().length === 0,
  );

  constructor() {
    this.route.queryParamMap.subscribe((params) => {
      if (params.has("entityType")) {
        this.updateImportSettings({ entityType: params.get("entityType") });
      }
      if (params.has("additionalAction")) {
        const action = JSON.parse(params.get("additionalAction"));
        this.updateImportSettings({ additionalActions: [action] });
      }
    });
  }

  updateImportSettings(patch: Partial<ImportSettings>) {
    this.importSettings.update((settings) => ({ ...settings, ...patch }));
  }

  async reset(skipConfirmation?: boolean) {
    if (
      !skipConfirmation &&
      !(await this.confirmationDialog.getConfirmation(
        $localize`:Import Reset Confirmation title:Cancel Import?`,
        $localize`:Import Reset Confirmation text:Do you really want to discard the currently prepared import?`,
      ))
    ) {
      return;
    }
    const currentRoute = this.location.pathname;
    return this.router
      .navigate([""], { skipLocationChange: true })
      .then(() =>
        this.router.navigate([currentRoute], { skipLocationChange: true }),
      );
  }

  onDataLoaded(data: ParsedData) {
    this.rawData = data.data;
    this.updateImportSettings({ filename: data.filename });

    if (this.importSettings().columnMapping?.some((m) => m.propertyName)) {
      this.alertService.addInfo(
        $localize`:alert info after file load:Column Mappings have been reset`,
      );
    }
    this.onColumnMappingUpdate(
      data.fields.map((field) => ({ column: field, propertyName: undefined })),
    );
  }

  onEntityTypeChange(newType: string) {
    // reset settings that reference the previous type's fields / link actions
    this.updateImportSettings({
      entityType: newType,
      importExisting: undefined,
      additionalActions: undefined,
    });
    if (this.importSettings().columnMapping?.length) {
      this.onColumnMappingUpdate(
        this.importSettings().columnMapping.map(({ column }) => ({
          column,
          propertyName: undefined,
        })),
      );
    }
  }

  onColumnMappingUpdate(newColumnMapping: ColumnMapping[]) {
    this.updateImportSettings({ columnMapping: newColumnMapping });
  }

  applyPreviousMapping(importMetadata: ImportMetadata) {
    this.updateImportSettings({
      entityType: importMetadata.config.entityType,
      additionalActions: importMetadata.config.additionalActions,
    });

    const currentColumnMapping = this.importSettings().columnMapping;
    if (!currentColumnMapping) {
      return;
    }

    const adjustedMappings = currentColumnMapping.map(
      ({ column }) =>
        importMetadata.config.columnMapping.find(
          (c) => column === c.column,
        ) ?? { column },
    );

    // TODO: load additionalActions also

    this.onColumnMappingUpdate(adjustedMappings);
  }

  onImportCompleted() {
    return this.reset(true);
  }
}