import { Component, Inject, OnInit } from "@angular/core";
import { MatDialogRef, MAT_DIALOG_DATA } from "@angular/material/dialog";
import { FormsModule } from "@angular/forms";

export interface ExecuteDialogData {
  records: any[];
  count: number;
  moduleName: string;
  message: string;
  requiresConfirmation?: boolean;
  showInputField?: boolean;
  inputFieldLabel?: string;
  inputFieldPlaceholder?: string;
  inputFieldMaxLength?: number;
  inputFieldRequired?: boolean;
  title?: string;
  confirmButtonText?: string;
  action?: string;

  // ===== Nouvelles propriétés pour SPC =====
  operationType?: string; // Type d'opération SPC
  hasPrefix?: boolean;    // Si la commande a un préfixe
  prefix?: string;        // Valeur du préfixe (TTP/, FHE, etc.)
  from?: string;          // Paramètre "from" pour le backend
  uuid?: string;          // UUID pour l'opération
  icon?: string;          // Icône spécifique à l'opération
  helpText?: string;      // Texte d'aide contextuel
  isOptional?: boolean;   // Si la commande est optionnelle
}

@Component({
  selector: "app-modal-execute",
  templateUrl: "./modal-execute.component.html",
  styleUrls: ["./modal-execute.component.scss"],
})
export class ModalExecuteComponent implements OnInit {
  public confirmationChecked: boolean = false;
  public inputFieldValue: string = '';

  constructor(
    public dialogRef: MatDialogRef<ModalExecuteComponent>,
    @Inject(MAT_DIALOG_DATA) public data: ExecuteDialogData
  ) {}

  ngOnInit(): void {
    // Initialiser les valeurs par défaut si nécessaire
    if (this.data.requiresConfirmation === undefined) {
      this.data.requiresConfirmation = true;
    }
    if (this.data.inputFieldMaxLength === undefined) {
      this.data.inputFieldMaxLength = 50;
    }
    if (this.data.title === undefined) {
      this.data.title = 'Confirmation d\'exécution';
    }
    if (this.data.confirmButtonText === undefined) {
      this.data.confirmButtonText = 'Exécuter';
    }
    if (this.data.action === undefined) {
      this.data.action = 'execute';
    }
  }

  /**
   * Annule l'opération et ferme la modal
   */
  onCancel(): void {
    this.dialogRef.close({
      confirmed: false,
      action: "cancelled",
    });
  }

  /**
   * Confirme l'exécution et ferme la modal
   */
  onConfirm(): void {
    console.log("🔄 ModalExecuteComponent.onConfirm() appelé");
    console.log("📋 État de confirmation:", {
      requiresConfirmation: this.data.requiresConfirmation,
      confirmationChecked: this.confirmationChecked,
      records: this.data.records,
      moduleName: this.data.moduleName,
      inputFieldValue: this.inputFieldValue,
      operationType: this.data.operationType,
    });

    // Vérifier si la confirmation est requise et cochée
    if (this.data.requiresConfirmation && !this.confirmationChecked) {
      console.log("⚠️ Confirmation requise mais pas cochée");
      return;
    }

    // Vérifier si le champ de saisie est requis et rempli (sauf si optionnel)
    if (this.data.showInputField && this.data.inputFieldRequired && !this.data.isOptional && !this.inputFieldValue.trim()) {
      console.log("⚠️ Champ de saisie requis mais vide");
      return;
    }

    console.log("✅ Fermeture de la modal avec confirmation");

    // Préparer le résultat selon le type d'opération
    const result: any = {
      confirmed: true,
      action: this.data.action || "execute",
      records: this.data.records,
      moduleName: this.data.moduleName,
      inputValue: this.inputFieldValue.trim(),
    };

    // Si c'est une opération SPC, ajouter le payload structuré
    if (this.isSpcOperation()) {
      result.spcPayload = this.getExecutionPayload();
      result.fullCommand = this.getFullCommand();
    }

    this.dialogRef.close(result);
  }

  /**
   * Gère la fermeture de la modal via la touche Échap
   */
  onNoClick(): void {
    this.onCancel();
  }

  /**
   * Gère le changement d'état de la checkbox de confirmation
   */
  onCheckboxChange(event: Event): void {
    const target = event.target as HTMLInputElement;
    this.confirmationChecked = target.checked;
  }

  /**
   * Vérifie si le bouton de confirmation doit être désactivé
   */
  isConfirmDisabled(): boolean {
    // Si confirmation requise et non cochée
    if (this.data.requiresConfirmation && !this.confirmationChecked) {
      return true;
    }

    // Si champ de saisie requis et vide (sauf si optionnel)
    if (this.data.showInputField && this.data.inputFieldRequired && !this.data.isOptional && !this.inputFieldValue.trim()) {
      return true;
    }

    return false;
  }

  /**
   * Retourne la commande complète avec préfixe si nécessaire
   */
  getFullCommand(): string {
    if (!this.data.hasPrefix || !this.data.prefix) {
      return this.inputFieldValue;
    }
    return this.data.prefix + this.inputFieldValue;
  }

  /**
   * Vérifie si c'est une opération SPC
   */
  isSpcOperation(): boolean {
    return !!this.data.operationType;
  }

  /**
   * Retourne le payload pour le backend selon le type d'opération
   */
  getExecutionPayload(): any {
    const payload: any = {
      operation_type: this.data.operationType,
      type: this.data.operationType
    };

    // Ajouter command_user si nécessaire
    if (this.data.showInputField) {
      const commandUser = this.getFullCommand();
      if (commandUser || !this.data.inputFieldRequired) {
        payload.command_user = commandUser;
      }
    }

    // Ajouter from si nécessaire
    if (this.data.from) {
      payload.from = this.data.from;
    }

    // Ajouter uuid si nécessaire
    if (this.data.uuid) {
      payload.uuid = this.data.uuid;
    }

    // Cas spécial pour office_id
    if (this.data.operationType === 'office_id') {
      payload.office_id = this.inputFieldValue;
    }

    return payload;
  }
}
