import { Injectable } from '@angular/core';
import { Router } from '@angular/router';
import { ApiService } from './api.service';
import { UtilsService } from './utils.service';
import { TranslateService } from '@ngx-translate/core';

@Injectable({
  providedIn: 'root'
})
export class AcademyService {

  academyParameters = [];
  constructor(
    public api: ApiService,
    private utilsService: UtilsService,
    private router: Router,
    public translateService: TranslateService) { }

  //-------------------------------------------api_functions------------------------------------------------------------
  async getFromAcademyUsers(typeAcademy) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.get("academy/getAcademyUsersInfo/" + typeAcademy, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (academyUsers: any) => {
          resolve(academyUsers);
        },
        (error) => {
          reject(error);
        }
      );
    });
  }

  async goToRenewalAcademyUsers(userId) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.post("academy/renewalUser", {
        userId
      }, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (academyUsers: any) => {
          resolve(academyUsers);
        },
        (error) => {
          reject(error);
        }
      );
    });
  }


  async getFromAcademyUser(id) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.get("academy/getAcademyUser/" + id, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (academyUser: any) => {
          resolve(academyUser);
        },
        (error) => {
          reject(error);
        }
      );
    });
  }

  public studentFullEnrollment(formData) {
    return new Promise(async (resolve, reject) => {
      return (await this.api.postFile("academy/completeUserAcademyData", formData, await this.utilsService.getAccessToken())).subscribe(
        (res: any) => {
          resolve(res);
        },
        (err) => {
          reject(err);
          console.error("error provider studentFullEnrollment: ", err);
        }
      );
    });
  }

  async getParameters(typeAcademy) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.get("academy/getParameters/" + typeAcademy, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (res: any) => {
          this.academyParameters = res;
          resolve(res);
        },
        (err) => {
          console.error("Error getParemeters", err);
          reject(err);
        }
      );
    });
  }

  getParameterValue(key: any) {
    let parameter: any = this.academyParameters.filter((x: any) => x.key === key)[0];
    return parameter ? parameter.value : '';
  }

  public async getLocations(typeAcademy) {
    return this.api.get("academy/getLocations/" + typeAcademy, await this.utilsService.getAccessToken());
  }

  public async getCategories(location?) {
    return this.api.get("academy/getCategories/" + location, await this.utilsService.getAccessToken());
  }

  public async getSchedules(category?) {
    return this.api.get("academy/getSchedules/" + category, await this.utilsService.getAccessToken());
  }

  public async getDiscounts(location) {
    return this.api.get("academy/getDiscounts/" + location, await this.utilsService.getAccessToken());
  }

  academyEnrollment(formData) {
    return new Promise(async (resolve, reject) => {
      return (await this.api.postFile("academy/createUserAcademy", formData, await this.utilsService.getAccessToken())).subscribe(
        (res: any) => {
          resolve(res);
        },
        (err) => {
          reject(err);
          console.error("error provider academyEnrollment: ", err);
        }
      );
    });
  }

  async getDocuments(user, externalFormExclusive) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.get("academy/getDocuments/" + user.id + '/' + user.type_academy + (externalFormExclusive ? ('/' + externalFormExclusive) : ''), await this.utilsService.getAccessToken());
      (await seq).subscribe({
        next: (res: any) => {
          resolve(res);
        },
        error: (err) => {
          console.error("error provider getDocuments: ", err);
          reject(err);
        },
        complete: () => { },
      });
    });
  }

  uploadUserAcademyDocument(formData) {
    return new Promise(async (resolve, reject) => {
      return (await this.api.postFile("academy/uploadUserAcademyDocument", formData, await this.utilsService.getAccessToken())).subscribe(
        (res: any) => {
          resolve(res);
        },
        (err) => {
          reject(err);
          console.error("error provider uploadUserAcademyDocument: ", err);
        }
      );
    });
  }

  uploadPendingUserAcademyDocument(formData) {
    return new Promise(async (resolve, reject) => {
      return (await this.api.post("academy/uploadPendingUserAcademyDocument", formData, await this.utilsService.getAccessToken())).subscribe(
        (res: any) => {
          resolve(res);
        },
        (err) => {
          reject(err);
          console.error("error provider uploadPendingUserAcademyDocument: ", err);
        }
      );
    });
  }

  async finishUploadDocuments(userId) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.get("academy/finishUploadDocuments/" + userId, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (resp: any) => {
          resolve(resp);
        },
        (error) => {
          reject(error);
        }
      );
    });
  }

  async academyPurchasePending(academy_user_id, type_payment) {
    let info = {
      academy_user_id,
      type_payment
    };
    return this.api.post(`academy/createAcademyPurchasePending`, info, await this.utilsService.getAccessToken());
  }

  async getAcademyPeriods(params) {
    return this.api.get(`academy/getPeriodsByMonthsQuantity`, await this.utilsService.getAccessToken(), params);
  }

  async createPaymentSchedule(info) {
    return this.api.post(`academy/createPaymentSchedule`, info, await this.utilsService.getAccessToken());
  }

  async getFromAcademyPayment(academy_user_id: number, take?: number, offset?: number) {
    let info = {
      academy_user_id,
      take,
      offset
    };
    return this.api.post(`academy/getAcademyPaymentsInfo`, info, await this.utilsService.getAccessToken());
  }

  uploadPaymentSupport(data) {
    return new Promise(async (resolve, reject) => {
      return (await this.api.postFile("academy/uploadPaymentSupport", data, await this.utilsService.getAccessToken())).subscribe(
        (res: any) => {
          resolve(res);
        },
        (err) => {
          reject(err);
          console.error("error provider uploadPaymentSupport: ", err);
        }
      );
    });
  }

  uploadTournamentPaymentSupport(data) {
    return new Promise(async (resolve, reject) => {
      return (await this.api.postFile("academy/uploadTournamentPaymentSupport", data, await this.utilsService.getAccessToken())).subscribe(
        (res: any) => {
          resolve(res);
        },
        (err) => {
          reject(err);
          console.error("error provider uploadTournamentPaymentSupport: ", err);
        }
      );
    });
  }

  updateUserPhoto(data) {
    return new Promise(async (resolve, reject) => {
      return (await this.api.postFile("academy/updateAcademyUserPhoto", data, await this.utilsService.getAccessToken())).subscribe(
        (res: any) => {
          resolve(res);
        },
        (err) => {
          reject(err);
          console.error("error provider updateUserPhoto: ", err);
        }
      );
    });
  }

  autocomplete(data) {
    return new Promise(async (resolve, reject) => {
      return (await this.api.post("sign/autocomplete", data, await this.utilsService.getAccessToken())).subscribe({
        next: (res: any) => {
          resolve(res);
        },
        error: (err) => {
          console.error("error provider autocomplete: ", err);
          reject(err);
        },
        complete: () => { },
      });
    });
  }

  async getReports(academyUserId) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.get("academy/getReportsAcademyUsers/" + academyUserId, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (resp: any) => {
          resolve(resp);
        },
        (error) => {
          reject(error);
          console.error("error provider getReports: ", error);
        }
      );
    });
  }

  async getPendingMonths(academyUserId) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.get("academy/getPendingMonths/" + academyUserId, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (resp: any) => {
          resolve(resp);
        },
        (error) => {
          reject(error);
          console.error("error provider getPendingMonths: ", error);
        }
      );
    });
  }

  async deletePayment(academyPaymentId) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.get("academy/deletePayment/" + academyPaymentId, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (resp: any) => {
          resolve(resp);
        },
        (error) => {
          reject(error);
          console.error("error provider deletePayment: ", error);
        }
      );
    });
  }

  async validateScheduleAvailability(academyScheduleId) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.get("academy/validateScheduleAvailability/" + academyScheduleId, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (resp: any) => {
          resolve(resp);
        },
        (error) => {
          reject(error);
          console.error("error provider validateScheduleAvailability: ", error);
        }
      );
    });
  }

  async changeSchedule(info) {
    return this.api.post(`academy/changeSchedule`, info, await this.utilsService.getAccessToken());
  }

  // APIs TORNEOS
  async getUserAcademyTournaments(academyUserId: number, take?: number, offset?: number) {
    let info = { academyUserId, take, offset };
    return this.api.post(`academy/getUserAcademyTournaments`, info, await this.utilsService.getAccessToken());
  }

  async getAcademyTournaments(academyUserId: number) {
    return this.api.get(`academy/getAcademyTournaments/` + academyUserId, await this.utilsService.getAccessToken());
  }

  async createTournamentPayment(info: any) {
    return this.api.post(`academy/createTournamentPayment`, info, await this.utilsService.getAccessToken());
  }

  async validateTournamentAvailability(academyTournamentPaymentId: number) {
    return new Promise(async (resolve, reject) => {
      let request = this.api.get(`academy/validateTournamentPaymentAvailability/` + academyTournamentPaymentId, await this.utilsService.getAccessToken());
      (await request).subscribe({
        next: (res: any) => {
          resolve(res);
        },
        error: (err) => {
          console.error("error provider validateTournamentAvailability: ", err);
          reject(err);
        },
        complete: () => { },
      });
    });
  }

  async createNew(info: any) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.post(`academy/createNew`, info, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (resp: any) => {
          resolve(resp);
        },
        (error) => {
          reject(error);
          console.error("error provider validateScheduleAvailability: ", error);
        }
      );
    });
  }

  async getAcademyNews(academyUserId) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.get("academy/getAcademyNews/" + academyUserId, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (academyUser: any) => {
          resolve(academyUser);
        },
        (error) => {
          reject(error);
        }
      );
    });
  }

  async deleteDocument(documentId, academyUserId) {
    return new Promise(async (resolve, reject) => {
      let seq = this.api.get("academy/deleteDocument/" + documentId + "/" + academyUserId, await this.utilsService.getAccessToken());
      (await seq).subscribe(
        (resp: any) => {
          resolve(resp);
          console.log("res deleteDocument: ", resp);
        },
        (error) => {
          reject(error);
          console.error("error provider deleteDocument: ", error);
        }
      );
    });
  }

  async validateGuardianInformation(data) {
    return new Promise(async (resolve, reject) => {
      let request = this.api.get("academy/validateGuardianInformation", await this.utilsService.getAccessToken(), data);
      (await request).subscribe({
        next: (res: any) => {
          resolve(res);
        },
        error: (err) => {
          console.error("error provider validateGuardianInformation: ", err);
          reject(err);
        },
        complete: () => { },
      });
    });
  }

  public updateGuardianInformation(formData) {
    return new Promise(async (resolve, reject) => {
      return (await this.api.post("academy/updateGuardianInformation", formData, await this.utilsService.getAccessToken())).subscribe({
        next: (res: any) => {
          resolve(res);
        },
        error: (err) => {
          console.error("error provider updateGuardianInformation: ", err);
          reject(err);
        },
        complete: () => { },
      });
    });
  }

  async validatePaymentAvailability(data) {
    return new Promise(async (resolve, reject) => {
      let request = this.api.get("payment/validatePaymentAvailability", await this.utilsService.getAccessToken(), data);
      (await request).subscribe({
        next: (res: any) => {
          resolve(res);
        },
        error: (err) => {
          console.error("error provider validatePaymentAvailability: ", err);
          reject(err);
        },
        complete: () => { },
      });
    });
  }
  //-----------------------------------------END_api_functions----------------------------------------------------------

  //--------------------------------------functional_functions----------------------------------------------------------
  goToPaymentGateway(academyPurchaseId: number, assignedPaymentGateway?: number, academyUserId?: number) {
    this.router.navigate(["/payment-gateway-selection"], { state: { academyPurchaseId: academyPurchaseId, assignedPaymentGateway: assignedPaymentGateway, academyUserId: academyUserId } });
  }

  goToTournamentPaymentGateway(academyTournamentPaymentId: number, assignedPaymentGateway?: number, academyUserId?: number) {
    this.router.navigate(["/payment-gateway-selection"], { state: { academyTournamentPaymentId: academyTournamentPaymentId, assignedPaymentGateway: assignedPaymentGateway, academyUserId: academyUserId } });
  }

  getAdvisorSectionTitle(typeAcademy) {
    if (typeAcademy == 'adult') {
      return this.translateService.instant("EMERGENCY_CONTACT");
    }
    return this.translateService.instant("PARENTS_INFORMATION");
  }
  //------------------------------------END_functional_functions--------------------------------------------------------
}