import { inject } from '@angular/core';
import { TranslateService } from '@ngx-translate/core';
import { Component, Input, OnInit } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Router } from "@angular/router";
import { ToastrService } from "ngx-toastr";
import { ConfigService } from '@services/config.service';
import { BootSoPartitionComponent } from "./boot-so-partition/boot-so-partition.component";
import { MatDialog } from "@angular/material/dialog";
import { RemoveCacheImageComponent } from "./remove-cache-image/remove-cache-image.component";
import { AuthService } from '@services/auth.service';
import {SoftwareProfilePartitionComponent} from "./software-profile-partition/software-profile-partition.component";
import { QueueConfirmationModalComponent } from '../../../../shared/queue-confirmation-modal/queue-confirmation-modal.component';
import { ExecuteTaskNowComponent } from './execute-task-now/execute-task-now.component';

@Component({
  selector: 'app-execute-command',
  templateUrl: './execute-command.component.html',
  styleUrls: ['./execute-command.component.css']
})
export class ExecuteCommandComponent implements OnInit {
  public translate = inject(TranslateService);
  @Input() runScriptContext: any = null;
  @Input() organizationalUnit: any = null;
  @Input() showOnlyDirectClients: boolean = false;
  @Input() clientState: string = 'off';
  @Input() clientData: any[] = [];
  @Input() buttonType: 'icon' | 'text' | 'menu-item' = 'icon';
  @Input() buttonText: string = 'Ejecutar Comandos';
  @Input() icon: string = 'terminal';
  @Input() disabled: boolean = false;
  baseUrl: string;
  loading: boolean = true;
  isFetchingOuClients: boolean = false;

  arrayCommands: any[] = [
    { translationKey: 'executeCommands.powerOn', slug: 'power-on', disabled: false },
    { translationKey: 'executeCommands.powerOff', slug: 'power-off', disabled: false },
    { translationKey: 'executeCommands.reboot', slug: 'reboot', disabled: false },
    { translationKey: 'executeCommands.login', slug: 'login', disabled: false },
    { translationKey: 'executeCommands.createImage', slug: 'create-image', disabled: false },
    { translationKey: 'executeCommands.deployImage', slug: 'deploy-image', disabled: false },
    { translationKey: 'executeCommands.deleteImageCache', slug: 'remove-cache-image', disabled: false },
    { translationKey: 'executeCommands.partition', slug: 'partition', disabled: false },
    { translationKey: 'executeCommands.softwareInventory', slug: 'software-inventory', disabled: false },
    { translationKey: 'executeCommands.hardwareInventory', slug: 'hardware-inventory', disabled: false },
    { translationKey: 'executeCommands.runScript', slug: 'run-script', disabled: false },
    { translationKey: 'executeCommands.refresh', slug: 'refresh', disabled: false },
    { translationKey: 'executeCommands.deleteLease', slug: 'delete-lease', disabled: false },
    { translationKey: 'executeCommands.executeTask', slug: 'execute-task', disabled: false },
  ];

  client: any = {};

  constructor(
    private http: HttpClient,
    private router: Router,
    private configService: ConfigService,
    private toastService: ToastrService,
    public auth: AuthService,
    private dialog: MatDialog,
  ) {
    this.baseUrl = this.configService.apiUrl;
  }

  ngOnInit(): void {
    this.clientData = this.clientData || [];
    const allowed = this.getAllowedCommandsByRole();
    this.arrayCommands = this.arrayCommands.filter(c => allowed.includes(c.slug));

    this.updateCommandStates();
  }

  ngOnChanges(): void {
    this.updateCommandStates();
  }

  private getAllowedCommandsByRole(): string[] {
    const role = this.auth.userCategory;

    const permissions: Record<string, string[]> = {
      'super-admin': ['*'],
      'ou-admin': ['*'],
      'ou-operator': [
        'power-on',
        'power-off',
        'reboot',
        'login',
        'create-image',
        'deploy-image',
        'software-inventory',
        'hardware-inventory',
        'remove-cache-image',
        'partition',
        'refresh',
        'delete-lease',
        'execute-task'
      ],
      'ou-minimal': [
        'power-on',
        'power-off'
      ]
    };

    const allowed = permissions[role] || [];
    return allowed.includes('*') ? this.arrayCommands.map(c => c.slug) : allowed;
  }


  private updateCommandStates(): void {
    let states: string[] = [];

    if (this.clientData.length > 0) {
      states = this.clientData.map(client => client.status);
    } else if (this.clientState) {
      states = [this.clientState];
    }

    const hasClients = this.clientData.length > 0 || !!this.clientState;
    const multipleClients = this.clientData.length > 1;
    const hasOgLive = states.some(state => state === 'og-live');

    // Acciones que admiten encolado o son independientes del estado del cliente
    const queueableOrStateAgnostic = [
      'power-on',
      'power-off',
      'reboot',
      'login',
      'deploy-image',
      'partition',
      'run-script',
      'execute-task',
      'delete-lease'
    ];

    this.arrayCommands = this.arrayCommands.map(command => {
      if (!hasClients) {
        command.disabled = true;
        return command;
      }

      // Restricciones lógicas estrictas
      if (command.slug === 'create-image') {
        command.disabled = multipleClients || !hasOgLive;
      } else if (command.slug === 'hardware-inventory' || command.slug === 'software-inventory') {
        command.disabled = multipleClients || !hasOgLive;
      } else if (command.slug === 'remove-cache-image') {
        command.disabled = !hasOgLive;
      } else if (command.slug === 'refresh') {
        command.disabled = !hasOgLive;
      } else if (queueableOrStateAgnostic.includes(command.slug)) {
        command.disabled = false;
      } else {
        command.disabled = false;
      }

      return command;
    });
  }

  onCommandSelect(action: any): void {
    if (this.organizationalUnit && this.organizationalUnit.id) {
      this.fetchClientsForOuAndExecute(action);
      return;
    }

    this.executeAction(action);
  }

  private fetchClientsForOuAndExecute(action: any): void {
    if (this.isFetchingOuClients) {
      return;
    }
    this.isFetchingOuClients = true;

    const unitId = this.organizationalUnit.id;
    this.http.get<any>(`${this.baseUrl}/clients?organizationalUnit.id=${unitId}&page=1&itemsPerPage=10000`).subscribe({
      next: (response) => {
        this.isFetchingOuClients = false;
        let allClients: any[] = response['hydra:member'] || [];

        if (this.showOnlyDirectClients && this.organizationalUnit['@id']) {
          allClients = allClients.filter((client: any) =>
            client.organizationalUnit?.['@id'] === this.organizationalUnit['@id']
          );
        }

        if (allClients.length === 0) {
          this.toastService.warning(this.translate.instant('thisOrganizationalUnitDoesNotHave') || 'Esta unidad organizativa no tiene clientes.');
          return;
        }

        this.clientData = allClients;
        this.executeAction(action);
      },
      error: (error) => {
        this.isFetchingOuClients = false;
        this.toastService.error(this.translate.instant('errorLoadingClients1') || 'Error al cargar los clientes');
      }
    });
  }

  private executeAction(action: any): void {
    if (action === 'partition') {
      this.openPartitionAssistant();
    }

    if (action === 'create-image') {
      this.openCreateImageAssistant();
    }

    if (action === 'deploy-image') {
      this.openDeployImageAssistant();
    }

    if (action === 'run-script') {
      this.openRunScriptAssistant();
    }

    if (action === 'login') {
      this.loginClient();
    }

    if (action === 'reboot') {
      this.rebootClient();
    }

    if (action === 'power-off') {
      this.powerOffClient();
    }

    if (action === 'power-on') {
      this.powerOnClient();
    }

    if (action === 'remove-cache-image') {
      this.removeImageCache();
    }

    if (action === 'hardware-inventory') {
      this.hardwareInventory();
    }

    if (action === 'software-inventory') {
      this.softwareInventory();
    }

    if (action === 'refresh') {
      this.refreshClient();
    }

    if (action === 'delete-lease') {
      this.deleteClientLease();
    }

    if (action === 'execute-task') {
      this.openExecuteTaskModal();
    }
  }

  openExecuteTaskModal(): void {
    this.dialog.open(ExecuteTaskNowComponent, {
      width: '500px',
      height: 'auto',
      data: { clients: this.clientData }
    });
  }

  rebootClient(): void {
    const dialogRef = this.dialog.open(QueueConfirmationModalComponent, {
      width: '400px',
      data: { clients: this.clientData }
    });

    dialogRef.afterClosed().subscribe((queue: boolean | undefined) => {
      if (queue === undefined) return;

      this.http.post(`${this.baseUrl}/clients/server/reboot`, {
        clients: this.clientData.map((client: any) => client['@id']),
        queue
      }).subscribe(
        () => { this.toastService.success(this.translate.instant('clientUpdatedSuccessfully')); },
        (error: any) => { this.toastService.error(error.error['hydra:description'] || 'Error de conexión con el cliente'); }
      );
    });
  }

  refreshClient(): void {
    this.http.post(`${this.baseUrl}/clients/server/refresh`, {
      clients: this.clientData.map((client: any) => client['@id'])
    }).subscribe(
      response => {
        this.toastService.success(this.translate.instant('refreshmentRequestSentCorrectly'));
      },
      error => {
        this.toastService.error(error.error['hydra:description'] || 'Error de conexión con el cliente');
      }
    );
  }

  loginClient(): void {
    const clientDataToSend = this.clientData.map(client => ({
      name: client.name,
      mac: client.mac,
      uuid: '/clients/' + client.uuid,
      status: client.status,
      partitions: client.partitions,
      firmwareType: client.firmwareType,
      ip: client.ip
    }));

    const dialogRef = this.dialog.open(BootSoPartitionComponent, {
      width: '70vw',
      height: 'auto',
      data: { clients: clientDataToSend }
    });

    dialogRef.afterClosed().subscribe(result => {
      if (result) {
        this.toastService.success(this.translate.instant('oSBootRequest'));
      }
    });
  }

  removeImageCache(): void {
    const clientDataToSend = this.clientData.map(client => ({
      name: client.name,
      mac: client.mac,
      uuid: '/clients/' + client.uuid,
      status: client.status,
      partitions: client.partitions,
      firmwareType: client.firmwareType,
      ip: client.ip
    }));

    const dialogRef = this.dialog.open(RemoveCacheImageComponent, {
      width: '70vw',
      height: 'auto',
      data: { clients: clientDataToSend }
    });

    dialogRef.afterClosed().subscribe(result => {
      if (result) {
        this.toastService.success(this.translate.instant('cacheClearRequest'));
      }
    });
  }

  hardwareInventory(): void {
    if (this.clientData.length === 0) {
      this.toastService.error(this.translate.instant('noClientsSelected'));
      return;
    }

    const clientId = this.clientData[0].uuid;

    this.http.post(`${this.baseUrl}/clients/server/${clientId}/hardware-inventory`, {
      clients: this.clientData.map((client: any) => client['@id'])
    }).subscribe(
      response => {
        this.toastService.success(this.translate.instant('hardwareInventorySuccessfullyUpdated'));
      },
      error => {
        this.toastService.error(error.error['hydra:description'] || 'Error de conexión con el cliente');
      }
    );
  }

  softwareInventory(): void {
    if (this.clientData.length === 0) {
      this.toastService.error(this.translate.instant('noClientsSelected'));
      return;
    }

    const clientDataToSend =  {
      clientId: this.clientData[0].uuid,
      name: this.clientData[0].name,
      mac: this.clientData[0].mac,
      status: this.clientData[0].status,
      partitions: this.clientData[0].partitions,
      firmwareType: this.clientData[0].firmwareType,
      ip: this.clientData[0].ip
    }

    const clientId = this.clientData[0].uuid;

    const dialogRef = this.dialog.open(SoftwareProfilePartitionComponent, {
      width: '70vw',
      height: 'auto',
      data: { client: clientDataToSend }
    });

    dialogRef.afterClosed().subscribe(result => {

    });
  }

  powerOnClient(): void {
    this.http.post(`${this.baseUrl}/image-repositories/wol`, {
      clients: this.clientData.map((client: any) => client['@id'])
    }).subscribe(
      response => {
        this.toastService.success(this.translate.instant('ignitionRequestSentCorrectly'));
      },
      error => {
        this.toastService.error(error.error['hydra:description'] || 'Error de conexión con el cliente');
      }
    );
  }

  powerOffClient(): void {
    const dialogRef = this.dialog.open(QueueConfirmationModalComponent, {
      width: '400px',
      data: { clients: this.clientData }
    });

    dialogRef.afterClosed().subscribe((queue: boolean | undefined) => {
      if (queue === undefined) return;

      this.http.post(`${this.baseUrl}/clients/server/power-off`, {
        clients: this.clientData.map((client: any) => client['@id']),
        queue
      }).subscribe(
        () => { this.toastService.success(this.translate.instant('shutdownRequestSentCorrectly')); },
        (error: any) => { this.toastService.error(error.error['hydra:description'] || 'Error de conexión con el cliente'); }
      );
    });
  }

  openPartitionAssistant(): void {
    const clientDataToSend = this.clientData.map(client => ({
      name: client.name,
      mac: client.mac,
      uuid: '/clients/' + client.uuid,
      status: client.status,
      partitions: client.partitions,
      firmwareType: client.firmwareType,
      ip: client.ip
    }));

    this.router.navigate(['/clients/partition-assistant'], {
      queryParams: {
        clientData: JSON.stringify(clientDataToSend),
        runScriptContext: JSON.stringify(this.runScriptContext)
      }
    });
  }

  openCreateImageAssistant(): void {
    this.router.navigate([`/clients/${this.clientData[0].uuid}/create-image`]).then(r => {
      console.log('navigated', r);
    });
  }

  openDeployImageAssistant(): void {
    const clientDataToSend = this.clientData.map(client => ({
      name: client.name,
      mac: client.mac,
      uuid: '/clients/' + client.uuid,
      status: client.status,
      partitions: client.partitions,
      ip: client.ip
    }));

    this.router.navigate(['/clients/deploy-image'], {
      queryParams: {
        clientData: JSON.stringify(clientDataToSend),
        runScriptContext: JSON.stringify(this.runScriptContext)
      }
    });
  }

  openRunScriptAssistant(): void {
    const clientDataToSend = this.clientData.map(client => ({
      name: client.name,
      mac: client.mac,
      uuid: '/clients/' + client.uuid,
      status: client.status,
      partitions: client.partitions,
      ip: client.ip
    }));

    this.router.navigate(['/clients/run-script'], {
      queryParams: {
        clientData: JSON.stringify(clientDataToSend),
        runScriptContext: JSON.stringify(this.runScriptContext)
      }
    })
  }

  deleteClientLease(): void {
    if (this.clientData.length === 0) {
      this.toastService.error(this.translate.instant('noClientsSelected'));
      return;
    }

    const requests = this.clientData.map((client: any) =>
      this.http.delete(`${this.baseUrl}/clients/${client.uuid}/delete-lease`).toPromise()
    );

    Promise.allSettled(requests).then(results => {
      const errors = results.filter(r => r.status === 'rejected');
      if (errors.length === 0) {
        this.toastService.success(this.translate.instant('dhcpLeasesRemovedSuccessfully'));
      } else if (errors.length < results.length) {
        this.toastService.warning(`${results.length - errors.length} lease(s) eliminada(s), ${errors.length} con error`);
      } else {
        this.toastService.error(this.translate.instant('errorWhenDeletingLeases'));
      }
    });
  }
}