import { SelectionModel } from '@angular/cdk/collections';
import { HttpErrorResponse } from '@angular/common/http';
import { AfterViewInit, Component, OnInit, ViewChild } from '@angular/core';
import { MatDialog } from '@angular/material/dialog';
import { MatTableDataSource } from '@angular/material/table';
import { ActivatedRoute, Router } from '@angular/router';
import { lastValueFrom } from 'rxjs';
import { ArtitleService } from 'src/app/services/acquisition-management/artitle.service';
import { EncService } from 'src/app/services/enc/enc.service';
import { ResourcesService } from 'src/app/services/resources/resources.service';
import { DetailsArtitleComponent } from '../details-artitle/details-artitle.component';
import { DataTableResponse, ContentArtitle, ProductoDetails, ResponseDataById, ArtitleResponse } from 'src/app/interfaces/acquisition-management/artitle.interface';
import { MatPaginator } from '@angular/material/paginator';
import { SliderData } from 'src/app/interfaces/slider.interface';
import { PurchasePurpose } from 'src/app/interfaces/acquisition-management/purchase-purpose.interface';
import { SocketService } from 'src/app/services/socket.service';
import { UsersProfilesService } from 'src/app/services/users-profiles.service';
import { UserConsultResponse } from 'src/app/interfaces/user.interface';
import { ProfileInterface } from 'src/app/interfaces/profile.interface';
import { PermissionsData } from '../../../acquisition-management.component';

@Component({
  selector: 'app-artitle-information.component',
  templateUrl: './artitle-information.component.html',
  styleUrls: ['./artitle-information.component.css']
})
export class ArtitleInformationComponent implements OnInit, AfterViewInit {

  public isLoading: boolean;
  public isError: boolean;

  public createGroupEnable: boolean;
  public cartShoppingEnabled: boolean;

  public displayedColumns: string[] = ['SELECT','MODELO','CODIGO','CARACTERISTICAS','PRECIO','ACCIONES'];
  public dataSource = new MatTableDataSource<DataTableResponse>([]);
  public selection = new SelectionModel<DataTableResponse>(true, []);

  public idDescArtitle:string;
  public idProvider:string;

  

  public artitle: ArtitleResponse;
  public quantityCarArtitle: number;

  public arrSlider: Array<SliderData>;

  private _purchasePurpose: PurchasePurpose;

  @ViewChild(MatPaginator) paginator!: MatPaginator;

  constructor(
    public resourcesService: ResourcesService,
    private dialog: MatDialog,
    private _activatedRouter: ActivatedRoute,
    private _encService: EncService,
    private _router: Router,
    private _artitleServices: ArtitleService,
    private _resourceService: ResourcesService,
    private _socketService: SocketService,
    private _usersProfilesSevice: UsersProfilesService,
  ) {
    this.isLoading = false;
    this.isError = false;
    this.createGroupEnable = true;
    this.cartShoppingEnabled = true;
    this.artitle = {} as ArtitleResponse;
    this._purchasePurpose = {} as PurchasePurpose;
    this.quantityCarArtitle = null !;
    this.idDescArtitle = "";
    this.arrSlider = [];
    this.idProvider = '';
  }

  async ngOnInit() {
    this.isLoading = true;
    await this.setPermissions();
    await this.refreshPermissions();
    await this.getPurchasePurpose();
    await this.getIdProviderAndIdArtitle();
    await this.getQuantityCarArtitle();
    this.isLoading = false;
  }

  ngAfterViewInit() {
    this.dataSource.paginator = this.paginator;
  }

  private async refreshPermissions() {
    this._socketService.refreshPermissions().subscribe(async (profUpdEnc) => {
      let idUser = localStorage.getItem('idusuario')!;
      let usrInfo: UserConsultResponse = await lastValueFrom(this._usersProfilesSevice.getUser(idUser, idUser, 1));
      let currentProfile = await this._encService.decrypt(localStorage.getItem('perfil')!);

      if(parseInt(currentProfile) != usrInfo.response.PERFIL){
        this._router.navigate(['/sam/home']);
      }

      let profileUpdated = await this._encService.decrypt(`${profUpdEnc}`);
      if(profileUpdated == currentProfile){
        let profile = localStorage.getItem('perfil')!;

        await lastValueFrom(this._usersProfilesSevice.getProfile( profile, idUser, 1 )).then(
          (responseData: ProfileInterface) => {
            if (!responseData.error) {
              let modPerm = responseData.response.PERMISOS.permissions.filter(item => item.id == 'S002V01M05GEAD')[0];
              let funPerm = modPerm.children.filter(item => item.id == 'S002V01S01ADQU')[0];
              let panPerm1 = funPerm.children.filter(item => item.id == "S002V01F01NSCO")[0];
              this.cartShoppingEnabled = panPerm1.children.filter(item => item.id == 'S002V01P04BOLS')[0].access > 0;
              
              let panPerm2 = funPerm.children.filter(item => item.id == "S002V01F02CGPE")[0];
              this.createGroupEnable = panPerm2.children.filter(item => item.id == 'S002V01P01AOCO')[0].access > 0;

              if (panPerm2.access === 0) {
                this._router.navigate(['/sam/home']);
              }

            } else {
              this.resourcesService.openSnackBar(`${responseData.msg}`);
            }
          }, ( httpErrorResponse: HttpErrorResponse ) => this.resourcesService.checkErrors(httpErrorResponse)
        );
      }
    });
  }

  private async setPermissions() {
    const encPermissions = localStorage.getItem('permisos');
    if (encPermissions === null || encPermissions === undefined || encPermissions === '') {
      this.resourcesService.openSnackBar(`Ocurrió un error al obtener los permisos del usuario.`);
      this._router.navigate(['/sam/home']);
      return;
    }
    const strPermissions:string = await this._encService.decrypt(encPermissions);
    const arrPermissions:Array<PermissionsData> = JSON.parse(strPermissions).permissions;

    let modPerm = arrPermissions.filter(item => item.id == 'S002V01M05GEAD')[0];
    let funPerm = modPerm.children.filter(item => item.id == 'S002V01S01ADQU')[0];
    let panPerm1 = funPerm.children.filter(item => item.id == "S002V01F01NSCO")[0];
    this.cartShoppingEnabled = panPerm1.children.filter(item => item.id == 'S002V01P04BOLS')[0].access > 0;
    
    let panPerm2 = funPerm.children.filter(item => item.id == "S002V01F02CGPE")[0];
    this.createGroupEnable = panPerm2.children.filter(item => item.id == 'S002V01P01AOCO')[0].access > 0;

    if (panPerm2.access === 0) {
      this._router.navigate(['/sam/home']);
    }
  }

  private async getPurchasePurpose() {
    const encInformation:string = this._activatedRouter.snapshot.paramMap.get('info')!;
    
    const strInformation:string = await this._encService.decrypt(encInformation);
    
    this._purchasePurpose = JSON.parse(strInformation);
  }

  // Método para obtener los ID del Artículo y del Proveedor para realizar la búsqueda
  private async getIdProviderAndIdArtitle(){
    const strPurchasePurpose:string = JSON.stringify(this._purchasePurpose);
    const encPurchasePurpose:string = await this._encService.encrypt(strPurchasePurpose);

    try{
      // Se obtiene el identificador del id del artículo encriptado
      const encIdArtitle:string = this._activatedRouter.snapshot.paramMap.get('idArtitle')!;
      this.idDescArtitle = await this._encService.decrypt(encIdArtitle);

      // Se obtiene el identificador del id del proveedor encriptado
      const encIdProvider:string = this._activatedRouter.snapshot.paramMap.get('idProvider')!;
      this.idProvider = await this._encService.decrypt(encIdProvider);
      
      const encInformation:string = this._activatedRouter.snapshot.paramMap.get('info')!;
      const strInformation:string = await this._encService.decrypt(encInformation);
      this._purchasePurpose = JSON.parse(strInformation);     


      // Se verifica que los ID sean válidos
      if ( (encIdArtitle !== '' && encIdArtitle !== null) && (encIdProvider !== '' && encIdProvider !== null)) {
        // Se obtiene el artículo seleccionado mediante los ID del artículo y el proveedor
        await this.getArtitle(encIdArtitle, encIdProvider);
      }else{
        this.resourcesService.openSnackBar('Ocurrió un error al obtener el identificador del artículo y/o proveedor, intentelo nuevamente.');
        this._router.navigate([`/sam/home`]);
      }
    }catch(error: any){
      this.resourcesService.openSnackBar('Ocurrió al desencriptar el identificador del artículo y/o proveedor.');
      this._router.navigate([`/sam/home`]);
    }
  }

  private async getArtitle(encIdArtitle:string, encIdProvider:string){

    await lastValueFrom(this._artitleServices.getArtitleByProvider(encIdArtitle, encIdProvider)).then(
      (responseData: ResponseDataById) => {

        if (!responseData.error) {
          this.artitle = responseData.response;
          this.artitle.URL_IMAGEN.forEach(element => {
            this.arrSlider.push({
              image: element,
            })
          });
          this.dataSource.data = this.setQuatityTable( JSON.parse(this.artitle.INFO_PRODUCTO) );
        } else {
          this.resourcesService.openSnackBar(`${responseData.msg}`)
        }

        
      }, (error: HttpErrorResponse) => {
        this._resourceService.checkErrors(error)
        this.isError = true;
      }
    );
  }

  // Colocación de la variable de CANTIDAD
  private setQuatityTable(arrTables: Array<DataTableResponse>): Array<DataTableResponse>{
    let arrNewData: Array<DataTableResponse> = [];
    arrTables.map( (element:DataTableResponse) => {
      element.CANTIDAD = 0;
      arrNewData.push(element);
    })
    return arrNewData;
  }

  // Método para obtener la cantidad de productos en el carrito
  public async getQuantityCarArtitle() {
    // Se obtiene los datos del localstorage del carrito de compra
    let localStorageCar = localStorage.getItem('car_shopping_artitles');
    // Se valida que la variable se encuentre en el localstorage
    let strItemsCar:string = localStorageCar !== null && localStorageCar !== undefined ?  localStorageCar : '';
    // Se verifica si hay articulos en el localstorage
    if (strItemsCar?.length === 0) {
      // Se coloca la cantidad como null
      this.quantityCarArtitle = null!;
    }else{
      // Se desencripta la cadena obtenida por el localstorage
      let decArtitlesSelected: string = await this._encService.decrypt(strItemsCar);
      // Se transforma a un arreglo los datos guardados del localstorage
      let arrCarShopping: Array<ContentArtitle> = JSON.parse(decArtitlesSelected);

      // Se ingresa la cantidad a la variable global
      arrCarShopping.map( (element:ContentArtitle) => {
        this.quantityCarArtitle += element.content.length;
      });
      this.quantityCarArtitle = this.quantityCarArtitle > 0 ? this.quantityCarArtitle : null!;
    }
  }

  // Agregar artículos al carrito de compra
  public async getShoppingCar() {
    let error: boolean = false;
    if (this.selection.selected.length === 0) {
      this._resourceService.openSnackBar("Selecciona un artículo antes de agregar al carrito.");
      error = true;
    }else{
      this.selection.selected.map( (element:DataTableResponse) => {
        if(element.CANTIDAD <= 0) {
          this._resourceService.openSnackBar("Los artículos seleccionados debe tener una cantidad asignada.");
          error = true;
        }
      });
    }

    // En caso de no haber un error, entonces
    if (!error) {
      // Se obtiene los datos del localstorage del carrito de compra
      let localStorageCar = localStorage.getItem('car_shopping_artitles');
      // Se valida que la variable se encuentre en el localstorage
      let strItemsCar:string = localStorageCar !== null && localStorageCar !== undefined ?  localStorageCar : '';

      /**
         * Caso 1: En caso no haber ningun artículo en el carrito, se inicializará el arreglo y se uniran los artículos
         * Caso 2: En caso de ya existir el mismo artículo en el carrito y del mismo producto, entonces solo se aumentará la cantidad en el carrito
         * Caso 3: En caso de ya existir el mismo artículo en el carrito pero diferente producto, entonces solo se agregará al contenido del artículo del carrito
         * Caso 4: En caso de no existir, entonces solo se ingresa el nuevo artículo en el carrito
         */

      // Se verifica si hay articulos en el localstorage
      if (strItemsCar?.length === 0) {
        // Caso 1
        // Objeto con el contenido a ingresar
        let artitlesSelected: ContentArtitle = {
          idArtitle: this.artitle.ID_ARTICULO,
          idDescArtitle: this.artitle.ID_DESC_ARTI,
          artitle: this.artitle.MODELO,
          idProvider: this.artitle.ID_PROVEEDOR,
          url_imagen: this.arrSlider,
          content: this.selection.selected
        }
        // Se inicializa la variable del carrito
        let arrArtitles: Array<ContentArtitle> = [];
        // Se ingresan los artíulos en el carrito
        arrArtitles.push(artitlesSelected);

        // El arreglo del carrito se transforma a una cadena
        let strArtitlesSelected: string = JSON.stringify( arrArtitles );

        // La cadena es encriptada para subirla al localstorage
        let encArtitlesSelected: string = await this._encService.encrypt(strArtitlesSelected);

        // Se guarda el carrito encriptado en el almacenamiento
        localStorage.setItem('car_shopping_artitles', encArtitlesSelected);
      }else{

        // Se desencripta la cadena obtenida por el localstorage
        let decArtitlesSelected: string = await this._encService.decrypt(strItemsCar);
        // Se transforma a un arreglo los datos guardados del localstorage
        let arrCarShopping: Array<ContentArtitle> = JSON.parse(decArtitlesSelected);

        // Caso 2
        // Se iteran todos los artículos del carrito
        arrCarShopping.map( (elementCarShopping:ContentArtitle, indexCarShopping:number) => {

          // Se identifica si existe el artículo seleccionado en el carrito
          if (elementCarShopping.idDescArtitle.toString() === this.idDescArtitle.toString()) {

            // En caso de existir, entonces se obtienen los productos seleccionados
            let arrContenido: Array<DataTableResponse> = elementCarShopping.content;
            // Se iteran los productos del carrito
            arrContenido.map( (elementContent:DataTableResponse, indexContent:number) => {
              // Se iteran los productos seleccionado
              this.selection.selected.map( (elementSelection:DataTableResponse, indexSelection:number) => {

                // Se identifica si algún producto del carrito coincide con los seleccionados
                if (elementContent.NUMERO_INFORMACION === elementSelection.NUMERO_INFORMACION) {
                  // Se le suma la cantidad seleccionada con la del carrito
                  elementContent.CANTIDAD += elementSelection.CANTIDAD;
                  // Se elimina el producto seleccioando ya que fue ya ingresado al carrito
                  this.selection.selected.splice(indexSelection, 1);
                }
              });
            });
            elementCarShopping.content = arrContenido;
          }
        });

        // Caso 3
        // Se veririca que existan datos seleccioandos
        if (this.selection.selected.length > 0) {
          // Se iteran todos los artículos del carrito
          arrCarShopping.map( (elementCarShopping:ContentArtitle, indexCarShopping:number) => {
            // Se identifica si existe el artículo seleccionado en el carrito
            if (elementCarShopping.idDescArtitle === this.idDescArtitle) {
              elementCarShopping.content = elementCarShopping.content.concat(this.selection.selected);
              this.selection.clear();
            }
          });
        }

        // Caso 4
        // Se veririca que existan datos seleccioandos
        if (this.selection.selected.length > 0) {
          // Objeto con el contenido a ingresar
          let artitlesSelected: ContentArtitle = {
            idArtitle: this.artitle.ID_ARTICULO,
            idDescArtitle: this.artitle.ID_DESC_ARTI,
            artitle: this.artitle.MODELO,
            idProvider: this.artitle.ID_PROVEEDOR,
            url_imagen: this.arrSlider,
            content: this.selection.selected
          }
          // Se ingresa el objeto con los nuevos artículos al carrito
          arrCarShopping.push(artitlesSelected);
        }


        // El arreglo ya unido se transforma a una cadena
        let strArtitlesSelected: string = JSON.stringify(arrCarShopping);
        // La cadena se encripta
        let encArtitlesSelected: string = await this._encService.encrypt(strArtitlesSelected);
        // Se coloca la cadena encriptra en el localstorage en la variable del carrito de compra
        localStorage.setItem('car_shopping_artitles', encArtitlesSelected);
      }
      // Se redirige al carrito
      this._resourceService.openSnackBar('¡Artículos Agregados!');

      const strPurchasePurpose:string = JSON.stringify(this._purchasePurpose);
      const encPurchasePurpose:string = await this._encService.encrypt(strPurchasePurpose);      
      this._router.navigate([ `/sam/GEAD/ADQU/CGPE/shopping-cart/${encPurchasePurpose}` ]);
    }
  }

  public async redirectShopping() {
    const strPurchasePurpose:string = JSON.stringify(this._purchasePurpose);
    const encPurchasePurpose:string = await this._encService.encrypt(strPurchasePurpose);      
    this._router.navigate([ `/sam/GEAD/ADQU/CGPE/shopping-cart/${encPurchasePurpose}` ]);
  }

  // Modificación de la cantidad de los productos
  public quantityProducts(accion: string, data: any) {
    this.dataSource.data.map( (element:any) => {
      if (element.NUMERO_INFORMACION === data.NUMERO_INFORMACION && accion == 'suma') {
        element.CANTIDAD ++;
      }else if (element.NUMERO_INFORMACION === data.NUMERO_INFORMACION && accion == 'resta') {
        element.CANTIDAD --;
      }
    } );
  }

  // Validación de la cantidad de los artículos
  public validateQuantity(cantidad: number, data: any){
    if (cantidad < 0 ) {
      this.dataSource.data.map( (element:any) => {
        if (element.NUMERO_INFORMACION === data.NUMERO_INFORMACION) {
          element.CANTIDAD = 0;
        }
      } );
    }
  }

  // Regresar a la pantalla anterior
  public goBack() {
    window.history.back();
  }

  // Abrir dialogos
  public openDialog(action: string, data: any = null) {
    if (action === 'VIEW') {

      let objArtitle: ProductoDetails = {
        ID_DESC_ARTI: this.artitle.ID_ARTICULO,
        ID_ARTICULO:this.artitle.ID_ARTICULO,
        CODIGO_ARTICULO: this.artitle.CODIGO,
        MODELO_ARTICULO: this.artitle.MODELO,
        ID_ARTICULO_FAMILIA: this.artitle.ID_FAMILIA,
        FAMILIA_ARTICULO: this.artitle.FAMILIA,
        ID_ARTICULO_SUBFAMILIA: this.artitle.ID_SUBFAMILIA,
        SUBFAMILIA_ARTICULO: this.artitle.SUBFAMILIA,
        DESCRIPCION_ARTICULO: this.artitle.DESCRIPCION,
        CARACTERISTICAS_ARTICULO: this.artitle.CARACTERISTICAS,
        COMPRA_ARTICULO_WEB: this.artitle.COMPRA_WEB,
        ID_UNIDAD: this.artitle.ID_UNIDAD,
        UNIDAD: this.artitle.UNIDAD,
        URL_ARTICULO_IMAGEN: this.artitle.URL_IMAGEN,
        ID_ARTICULO_PROVEEDOR: this.artitle.ID_PROVEEDOR,
        PROVEEDOR_ARTICULO: this.artitle.PROVEEDOR,
        CODIGO_PRODUCTO: data.CODIGO,
        MODELO_PRODUCTO: data.MODELO,
        PRECIO_PRODUCTO: data.PRECIO,
        CANTIDAD_PRODUCTO: data.CANTIDAD,
        CARACTERISTICAS_PRODUCTO: data.CARACTERISTICAS,
        NUMERO_PRODUCTO: data.NUMERO_PRODUCTO,
      }

      const dialogRef = this.dialog.open(DetailsArtitleComponent, {
        width: '800px',
        disableClose: true,
        data: objArtitle
      });
    }
  }


  public isAllSelected() {
    const numSelected = this.selection.selected.length;
    const numRows = this.dataSource.data.length;
    return numSelected === numRows;
  }

  public toggleAllRows() {
    if (this.isAllSelected()) {
      this.selection.clear();
      return;
    }
    this.selection.select(...this.dataSource.data);
  }

  public checkboxLabel(row?: any): string {
    if (!row) {
      return `${this.isAllSelected() ? 'deselect' : 'select'} all`;
    }
    return `${this.selection.isSelected(row) ? 'deselect' : 'select'} row ${row.codigo + 1}`;
  }
}
