import { Component, OnInit, ViewChild } from "@angular/core";
import { LoadingController, AlertController } from "@ionic/angular";
import { StorageService } from '../../services/storage.service';
import { Router } from "@angular/router";
import { IonInfiniteScroll } from "@ionic/angular";
import { OrderService } from "../../services/order.service";
import { CartService } from "../../services/cart.service";
import { TranslateService } from "@ngx-translate/core";
import { UtilsService } from "../../services/utils.service";
import { CorporateIdentityService } from "../../services/corporate-identity.service";

@Component({
  selector: "page-user-orders",
  templateUrl: "user-orders.html",
  styleUrls: ["./user-orders.scss"],
})
export class UserOrdersPage implements OnInit {
  orders: string = "";
  listOrdersFinished: any = [];
  offset = 0;
  take = 5;
  messageText: any;
  @ViewChild(IonInfiniteScroll) infiniteScroll: IonInfiniteScroll;
  currency: string;
  constructor(
    public orderProvider: OrderService,
    private storage: StorageService,
    public loadingCtrl: LoadingController,
    public cartProvider: CartService,
    public utilsService: UtilsService,
    public alertCtrl: AlertController,
    private translateService: TranslateService,
    private router: Router,
    private corporateIdentityService: CorporateIdentityService
  ) {
    // traduccion textos
    this.translateService
      .get(["TITLE_COPY_ORDER", "TEXT_COPY_ORDER", "TITLE_ORDER_CANCELLED", "TEXT_ORDER_CANCELLED", "ORDER_TEXT_CANCELED_BY_DISCOUNT"])
      .subscribe((values) => {
        this.messageText = {
          titleCopyOrder: values.TITLE_COPY_ORDER,
          textCopyOrder: values.TEXT_COPY_ORDER,
          titleOrderCancelled: values.TITLE_ORDER_CANCELLED,
          textOrderCancelled: values.TEXT_ORDER_CANCELLED,
          textCanceledByDiscount: values.ORDER_TEXT_CANCELED_BY_DISCOUNT
        };
      });

    this.orders = "pendientes";
    this.currency = this.corporateIdentityService.getCurrency();
  }

  ngOnInit() {
  }

  ionViewDidLoad() { }

  ionViewWillEnter() {
    if (this.orders == "pendientes") {
      this.orderProvider.getPendingOrders();
    }
  }

  toggleInfiniteScroll() {
    this.infiniteScroll.disabled = !this.infiniteScroll.disabled;
  }

  detailOrder(order_id) {
    this.router.navigate(["/app/tabs/settings/order/" + order_id + "/userOrders"]);
  }

  getListOrdersFinished(offset, take, infiniteScroll?) {
    this.storage.get("token").then((token) => {
      if (token) {
        this.storage.get("infoUser").then(async (infoUser) => {
          if (infoUser) {
            this.utilsService.presentLoading(this.translateService.instant("all.loading"));

            (await this.orderProvider.getFinishedOrders(offset, take, token.access_token)).subscribe(
              (data) => {
                if ((data["status"] = "success")) {
                  for (let i = 0; i < data["orders"].length; i++) {
                    this.listOrdersFinished.push(data["orders"][i]);
                  }
                  this.utilsService.dismissLoading();
                  if (infiniteScroll) {
                    infiniteScroll.target.complete();
                  }
                  if (this.offset > this.listOrdersFinished.length) {
                    this.toggleInfiniteScroll();
                  }
                }
              },
              (error) => {
                console.log("error getListOrdersFinished: ", error);
                this.utilsService.dismissLoading();
              }
            );
          }
        });
      }
    });
  }

  validationOrderForPayment(order: any) {
    let data = {
      orderId: order.id
    };
    this.storage.get("token").then(async (token) => {
      if (token) {
        (await this.cartProvider.validationOrderForPayment(data, token.access_token)).subscribe(
          (resp: any) => {
            var valid = resp.status;
            if (valid) {
              this.makePayment(order);
            } else {
              this.alertCancelOrder(order.id, resp.message, token.access_token);
            }
          },
          (error) => {
            console.log("Error validationOrderForPayment", error);
            this.utilsService.dismissLoading();
          }
        );
      }
    });
  }

  async alertCancelOrder(orderId, message, access_token) {
    let textMessage;
    if (message) {
      textMessage = this.messageText.textCanceledByDiscount;
    } else {
      textMessage = this.messageText.textOrderCancelled + message
    }
    this.alertCtrl.create({
      header: this.messageText.titleOrderCancelled,
      message: textMessage,
      buttons: [
        {
          text: 'Ok',
          handler: async () => {
            (await this.orderProvider.cancelOrder(orderId, access_token)).subscribe(
              (resp) => {
                if (!resp["r"]) {
                  this.utilsService.presentToast(5000, "warning", "top", resp["m"]);
                }
                this.orderProvider.getPendingOrders();
              },
              (error) => {
                console.log("Error alertCancelOrder", error);
              }
            );
          }
        }
      ]
    }).then(res => {
      res.present();
    });
  }

  makePayment(order: any) {
    // Gateway
    if (order.payment_type_id == 5) {
      this.router.navigate(["/payment-gateway-selection"], { state: { orderId: order.id, validateClose: false } });
    }
  }

  changedTypeOrder(e) {
    this.orderProvider._pendingOrders = [];
    if (e.detail.value == "finalizados") {
      this.offset = 0;
      this.listOrdersFinished = [];
      this.getListOrdersFinished(this.offset, this.take);
    } else {
      this.offset = 0;
      this.orderProvider._pendingOrders = [];
      this.orderProvider.getPendingOrders();
    }

    this.orders = e.detail.value;
  }

  moreOrders(infiniteScroll) {
    this.offset += 5;
    this.getListOrdersFinished(this.offset, this.take, infiniteScroll);
  }

  async copyOrder(products) {
    const confirm = await this.alertCtrl.create({
      header: this.messageText.titleCopyOrder,
      message: this.messageText.textCopyOrder,
      buttons: [
        {
          text: "No",
          handler: () => {
            console.log("Disagree clicked");
          },
        },
        {
          text: "Si",
          handler: () => {
            if (products) {
              this.cartProvider.copyProductsToOrder(products);
              setTimeout(() => {
                this.router.navigate(["/app/tabs/shop/cart"]);
              }, 500);
            }
          },
        },
      ],
    });
    await confirm.present();
  }

  doRefresh(event) {
    setTimeout(() => {
      this.orderProvider.getPendingOrders();
      event.target.complete();
    }, 500);
  }
}