import { Injectable } from "@angular/core";
import { StorageService } from './storage.service';
import { ApiService } from "./api.service";
import { UtilsService } from "./utils.service";
import { Router } from "@angular/router";
import { CityService } from "./city.service";

@Injectable({
  providedIn: "root",
})
export class HomeService {
  _listCategories: any = [];
  _listCategoriesBusiness: any = [];
  _listDirectoryBusiness: any = [];
  _listSymbolicBallots: any;
  _currentCategory: any;
  _teamData: any;
  _homeImage: any;
  _listForms: any = [];
  _activateNewsLink: boolean = true;
  _urlNewsLink: string = 'https://www.saprissa.com/noticias';
  _urlIframe: string;

  constructor(
    public api: ApiService,
    private storage: StorageService,
    public utilsService: UtilsService,
    private router: Router,
    public cityProvider: CityService,
  ) { }

  infoCategories(storeType?) {
    this.storage
      .get("token")
      .then(async (token) => {
        if (token) {
          this._listCategories = [];
          (await this.api.get("home/category/list/" + storeType, token.access_token)).subscribe(
            (res: any) => {
              if (res.status == "success") {
                this._listCategories = res.categories;
              }
            },
            (err) => {
              console.error("Error provider home infoCategories", err);
            }
          );
        }
      })
      .catch((error) => {
        console.log("error storage token", error);
      });
  }

  infoCategoriesBusiness() {
    this.storage
      .get("token")
      .then(async (token) => {
        if (token) {
          this._listCategoriesBusiness = [];
          (await this.api.get("home/categoryBusiness/list", token.access_token)).subscribe(
            (res: any) => {
              if (res.status == "success") {
                this._listCategoriesBusiness = res.business;
              }
            },
            (err) => {
              console.error("Error provider home infoCategoriesBusiness", err);
            }
          );
        }
      })
      .catch((error) => {
        console.log("error storage token", error);
      });
  }

  infoDirectoryBusiness() {
    this.storage
      .get("token")
      .then(async (token) => {
        if (token) {
          this._listDirectoryBusiness = [];
          (await this.api.get("home/categoryBusiness/list", token.access_token)).subscribe(
            (res: any) => {
              if (res.status == "success") {
                this._listDirectoryBusiness = res.business;
              }
            },
            (err) => {
              console.error("Error provider home infoCategoriesBusiness", err);
            }
          );
        }
      })
      .catch((error) => {
        console.log("error storage token", error);
      });
  }

  getSymbolicBallot() {
    this.storage
      .get("token")
      .then(async (token) => {
        if (token) {
          this._listSymbolicBallots = [];
          (await this.api.get("symbolic_tickets/get", token.access_token)).subscribe(
            (res: any) => {
              this._listSymbolicBallots = res;
            },
            (err) => {
              console.error("Error getSymbolicBallot", err);
            }
          );
        }
      })
      .catch((error) => {
        console.log("error storage token", error);
      });
  }

  getTeamData() {
    return new Promise(async (resolve, reject) => {
      (await this.api.get("team_main")).subscribe(
        (res: any) => {
          this._teamData = res;
          resolve(res);
        },
        (err) => {
          console.error("Error getTeamData", err);
          reject(err);
        }
      );
    });
  }

  listSubcategories(category_id, token) {
    let data = {
      category_id: category_id,
    };
    return this.api.post("home/subcategory/list", data, token);
  }

  listProductsSubcategory(subcategory_id, offset, take, valueOrder, orderSorting, storeType, token) {
    let data = {
      subcategory_id: subcategory_id,
      offset: offset,
      take: take,
      valueOrder: valueOrder,
      orderSorting: orderSorting,
    };
    return this.api.post("home/productsSubcategory/list/" + storeType, data, token);
  }

  getProductsTrends(offset, take, storeType, token) {
    let data = {
      offset: offset,
      take: take,
    };
    return this.api.post("home/productsTrends/" + storeType, data, token);
  }

  getProductsSubcategoryFilter(valueSearch, subCategory_id, offset, take, storeType, token) {
    let data = {
      valueSearch: valueSearch,
      subCategory_id: subCategory_id,
      offset: offset,
      take: take,
    };
    return this.api.post("home/productsSubcategoryFilter/" + storeType, data, token);
  }

  getProductsPlu(plu, token) {
    return this.api.get("home/getProductsPlu/" + plu, token);
  }

  getSymbolicPriceTicket(id_ticket_simbolico, token) {
    return this.api.get(`symbolic_tickets/get_prices/${id_ticket_simbolico}`, token);
  }

  symbolicTicketPending(symbolic_ticket_id, symbolic_ticket_price_id, quantity, token) {
    let info = {
      symbolic_ticket_id,
      symbolic_ticket_price_id,
      quantity,
    };
    return this.api.post(`symbolic_tickets/createSymbolicTicketPending`, info, token);
  }

  purchaseSymbolicTicket(ticket_pending_id: any) {
    let url = this.api.getUrl();
    let link = `${url}/symbolic_tickets/purchase/symbolic_ticket?uid=` + ticket_pending_id;
    this.utilsService.openLink(link);
  }

  purchaseSubscriberSymbolicTicket(uid: any, token) {
    let info = {
      uid
    };
    return this.api.post(`symbolic_tickets/purchaseSubscriber`, info, token);
  }

  getSimbolicTickets(take, offset) {
    return this.api.get(`symbolic_tickets/get_my_tickets/${take}/${offset}`);
  }

  openAction(type: number, value: any, target: any) {
    switch (type) {
      case 1: // Categoria
        value = parseInt(value);
        if (target.includes("business-directory")) {
          let directoryBusiness = this._listDirectoryBusiness.find((business: any) => business.id === value);
          if (directoryBusiness) {
            let onlyUser = false;
            this._listDirectoryBusiness = directoryBusiness;
            this.router.navigate(["/business-directory-list/" + this._listDirectoryBusiness.id + '/' + onlyUser + '/' + this._listDirectoryBusiness.name]);
          }
        } else if (target.includes("category-")) {
          let categoryBusiness = this._listCategoriesBusiness.find((business: any) => business.id === value);
          if (categoryBusiness) {
            let onlyUser = false;
            this._listCategoriesBusiness = categoryBusiness;
            this.router.navigate(["/business-directory-list/" + this._listCategoriesBusiness.id + '/' + onlyUser + '/' + this._listCategoriesBusiness.name]);
          }
        } else {
          let category = this._listCategories.find((category: any) => category.id === value);
          if (category) {
            this._currentCategory = category;
            this.router.navigate(["/app/tabs/shop/item-detail"]);
          }
        }
        break;

      case 2: // Link
        let link = value;
        this.utilsService.openLink(link);
        break;

      case 3: // Menu item
        this.router.navigate([value]);
        break;

      default:
        break;
    }
  }

  loadHomeImage() {
    this.storage
      .get("token")
      .then(async (token) => {
        if (token) {
          this._homeImage = "";
          (await this.api.get("homeImage/list", token.access_token)).subscribe(
            (res: any) => {
              if (res && res["status"] == "success" && res["homeImageList"]) {
                this._homeImage = this.cityProvider._urlGallery + "home_image/" + res["homeImageList"]["image"];
              }
            },
            (error) => {
              console.log('Error loadHomeImage', error);
            }
          );
        }
      })
      .catch((error) => {
        console.log("error storage token", error);
      });
  }

  getForms() {
    this.storage
      .get("token")
      .then(async (token) => {
        if (token) {
          let info = {
            show_in_home: true
          };

          (await this.api.post(`requests/forms`, info, token.access_token)).subscribe(
            (res: any) => {
              if (res.status == true) {
                this._listForms = res.data;
              }
            },
            (error) => {
              console.log('Error loadHomeImage', error);
            }
          );
        }
      })
      .catch((error) => {
        console.log("error storage token", error);
      });
  }

}