import { Injectable } from '@angular/core';
import { Observable } from 'rxjs/Observable';
import { Subject } from 'rxjs/Subject';
import 'rxjs/add/operator/map';

import { Offer } from './offer';

import { ApiProvider } from '../api/api.provider';

import * as _ from 'lodash';


@Injectable()
export class OffersProvider {
  public _offers$:   Subject<Offer[]>;
  public dataStore:  { offers: Offer[] };
  get offers$ ()      { return this._offers$.asObservable(); } // Is shown as ".offers$" attribute to consumers

  constructor(public apiProvider: ApiProvider) {
    this._offers$         = <Subject<Offer[]>> new Subject();
    let dummyOffer: Offer = Offer.createDummyOffer();
    this.dataStore        = { offers: [dummyOffer] };
  }

  initOffers(tenantId: string, storeId: string): Promise<Offer[]> {
    // If cache contains dummy initialisaton data, then clear it
    if (this.dataStore.offers[0].getOfferId() !== '__DUMMY__') {
      return new Promise( (resolve, reject) => { resolve(this.dataStore.offers); });
    } else {
      return new Promise( (resolve, reject) => { // TODO handle reject case
        this.retrieveOffers(tenantId, storeId)
          .then( (offers: Offer[]) => { resolve(offers); })
          .catch((errors: any[]) => {
            console.error(`Error on loadOffers() with response: error ${errors[0].code},  ${errors[0].msg}`);
            reject(errors);
          });
      });
    }
  }

  
  createOffer(
      tenantId:             string
      , storeId:            string
      , productId:          string
      , name:               string
      , description:        string
      , discountedPrice:    number
      , img_url:            string
    ): Promise<Offer> {
    let payload = {
        'tenantId':         tenantId
      , 'storeId':          storeId
      , 'productId':        productId
      , 'name':             name
      , 'description':      description
      , 'discountedPrice':  discountedPrice
      , 'img_url':          img_url
    };
    return new Promise( (resolve, reject) => {
      this.apiProvider.api('POST', '/v1/offer', payload)
        .then( (response: any) => {
          let newOffer: Offer = Offer.fromJson(response);
          resolve(newOffer);
          // If cache contains dummy initialisaton data, then clear it
          if (this.dataStore.offers[0].getProductName() !== 'DUMMY') {
            this.dataStore.offers.splice(0);
          }
          this.dataStore.offers.push(newOffer);
        })
        .catch((error: number) => {
          console.error(`Error on createOffer() api request with response: error ${error}`);
          reject(error);
        });
    });
  }

  retrieveOffers(tenantId: string, storeId: string): Promise<Offer[]> {
    let payload = {
      'tenantId'  : tenantId
      , 'storeId' : storeId
    };
    return new Promise( (resolve, reject) => {
      this.apiProvider.api('GET', '/v1/offers', payload)
        .then( (response: any[]) => {
          if (response.length > 0) {
            // Clear offers array before pushing in fresh data from api response
            this.dataStore.offers.splice(0);
            // Parse and copy data fetched from api into our cache
            _(response).forEach( (offer: any) => {
              this.dataStore.offers.push(Offer.fromJson(offer));
            });
            this._offers$.next(this.dataStore.offers);
            resolve(this.dataStore.offers);
          }
        })
        .catch((error_code: any) => {
          if (error_code === 700 || error_code === 400) {
            resolve([]);
          } else {
            console.error(`Error on retrieveOffers() api request with response: error ${error_code}`);
            reject(error_code);
          }
        });
    });
  }

  retrieveOfferDetails(offerId: string): Promise<Offer> {
    let payload = {};
    return  new Promise( (resolve, reject) => {
      this.apiProvider.api('GET', `/v1/offer/${offerId}`, payload)
        .then( (response: any) => {
          let retrievedOffer: Offer = Offer.fromJson(response);
          Offer.pushOfferIfUnique(retrievedOffer, this.dataStore.offers);
          this._offers$.next(this.dataStore.offers);
          resolve(retrievedOffer);
        })
        .catch((errors: any) => {
          console.error(`Error on retrieveOfferDetails() api request with response: error ${errors[0].code},  ${errors[0].msg}`);
          reject(errors);
        });
    });
  }

  updateOffer(
      offerId:              string
      , tenantId:           string
      , storeId:            string
      , productId:          string
      , name:               string
      , description:        string
      , discountedPrice:    number
      , img_url:            string
    ): Promise<Offer> {
    let payload = {
      'tenantId':           tenantId
      , 'storeId':          storeId
      , 'productId':        productId
      , 'name':             name
      , 'description':      description
      , 'price':  discountedPrice
      , 'img_url':          img_url
    };
    return new Promise( (resolve, reject) => {
      this.apiProvider.api('PUT', `/v1/offer/${offerId}`, payload)
        .then( (response: any) => {
          let updatedOffer: Offer = Offer.fromJson(response);
          Offer.updateOrPushOffer(updatedOffer, this.dataStore.offers);
          this._offers$.next(this.dataStore.offers);
          resolve(updatedOffer);
        })
        .catch((errors: any[]) => {
          console.error(`Error on updatedOffer() api request with response: error ${errors[0].code},  ${errors[0].msg}`);
          reject(errors);
        });
    });
  }

  deleteOffer(offerId: string): Promise<Offer> {
    let payload = {};
    return new Promise( (resolve, reject) => {
      this.apiProvider.api('DELETE', `/v1/offer/${offerId}`, payload)
        .then( (response: any) => {
          let deletedOffer: Offer = Offer.fromJson(response);
          Offer.deleteOffer(deletedOffer, this.dataStore.offers);
          this._offers$.next(this.dataStore.offers);
          resolve(deletedOffer);
        })
        .catch((errors: any[]) => {
          console.error(`Error on deleteOffer() api request with response: error ${errors[0].code},  ${errors[0].msg}`);
          reject(errors);
        });
    });
  }

}