import { reactive, computed, ComputedRef, WritableComputedRef } from '@vue/composition-api';
import { axios } from 'src/boot/axios';
import { AxiosResponse } from 'axios';

const state = reactive<{ drinks: Drink[]; tags: FG.Tag[]; drinkTypes: FG.DrinkType[] }>({
  drinks: [],
  tags: [],
  drinkTypes: []
});

interface MinPrice extends Omit<FG.DrinkMinPrice, 'price'> {
  price: WritableComputedRef<number> | null;
}
interface DrinkPriceVolume extends Omit<Omit<FG.DrinkPriceVolume, 'volume'>, 'min_prices'> {
  _volume: number;
  volume: WritableComputedRef<number> | null;
  min_prices: MinPrice[];
}
interface Drink extends Omit<FG.Drink, 'volumes'> {
  volumes: DrinkPriceVolume[];
}

const actions = {
  getDrinks() {
    axios
      .get('pricelist/drinks')
      .then((response: AxiosResponse<FG.Drink[]>) => {
        //state.drinks = [...response.data];
        /*state.drinks.forEach((drink: Drink) => {
          drink.volumes.forEach((volume: DrinkPriceVolume) => {
            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
            // @ts-ignore
            volume._volume = volume.volume;
            volume.volume = create_volume(drink, volume);
            volume.min_prices = [
              {
                percentage: 100,
                price: create_min_prices(drink, volume, 100)
              },
              {
                percentage: 250,
                price: create_min_prices(drink, volume, 250)
              },
              {
                percentage: 300,
                price: create_min_prices(drink, volume, 300)
              }
            ];
            this.sortPrices(volume);
          });
        });*/
        response.data.forEach(drink => {
          const newDrink: Drink = { ...drink, volumes: [] };
          drink.volumes.forEach(volume => {
            const newVolume: DrinkPriceVolume = {
              ...volume,
              _volume: volume.volume,
              min_prices: [],
              volume: null
            };
            newVolume.volume = create_volume(newDrink, newVolume);
            newVolume.min_prices = [
              {
                percentage: 100,
                price: create_min_prices(newDrink, newVolume, 100)
              },
              {
                percentage: 250,
                price: create_min_prices(newDrink, newVolume, 250)
              },
              {
                percentage: 300,
                price: create_min_prices(newDrink, newVolume, 300)
              }
            ];
            console.log(newVolume);
            newDrink.volumes.push(newVolume);
          });
          state.drinks.push(newDrink);
        });
      })
      .catch(err => console.warn(err));
  },
  setPrice(price: FG.DrinkPrice, volume: DrinkPriceVolume) {
    axios
      .post(`pricelist/volumes/${volume.id}/prices`, price)
      .then((response: AxiosResponse<FG.DrinkPrice>) => {
        volume.prices.push(response.data);
        this.sortPrices(volume);
      })
      .catch(err => console.warn(err));
  },
  sortPrices(volume: DrinkPriceVolume) {
    volume.prices.sort((a, b) => {
      if (a.price > b.price) return 1;
      if (b.price > a.price) return -1;
      return 0;
    });
  },
  deletePrice(price: FG.DrinkPrice, volume: FG.DrinkPriceVolume) {
    axios
      .delete(`pricelist/prices/${price.id}`)
      .then(() => {
        const index = volume.prices.findIndex(a => a.id == price.id);
        if (index > -1) {
          volume.prices.splice(index, 1);
        }
      })
      .catch(err => console.warn(err));
  },
  updatePrice(price: FG.DrinkPrice, volume: DrinkPriceVolume) {
    axios
      .put(`pricelist/prices/${price.id}`, price)
      .then((response: AxiosResponse<FG.DrinkPrice>) => {
        const index = volume.prices.findIndex(a => a.id === price.id);
        if (index > -1) {
          this.sortPrices(volume);
        }
      })
      .catch(err => console.log(err));
  },
  setVolume(volume: DrinkPriceVolume, drink: Drink) {
    console.log(volume);
    axios
      .post(`pricelist/drinks/${drink.id}/volumes`, { ...volume, volume: volume.volume })
      .then((response: AxiosResponse<FG.DrinkPriceVolume>) => {
        const a: DrinkPriceVolume = {
          ...response.data,
          min_prices: [],
          _volume: response.data.volume,
          volume: null
        };
        a.volume = create_volume(drink, a);
        a.min_prices = [
          {
            percentage: 100,
            price: create_min_prices(drink, a, 100)
          },
          {
            percentage: 250,
            price: create_min_prices(drink, a, 250)
          },
          {
            percentage: 300,
            price: create_min_prices(drink, a, 300)
          }
        ];
        console.log(a);
        drink.volumes.push(a);
      })
      .catch(err => console.warn(err));
  },
  updateVolume(volume: DrinkPriceVolume, drink: Drink) {
    axios
      .put(`pricelist/volumes/${volume.id}`, { ...volume, volume: volume.volume?.value })
      .catch(err => console.warn(err));
  },
  deleteVolume(volume: FG.DrinkPriceVolume, drink: FG.Drink) {
    axios
      .delete(`pricelist/volumes/${volume.id}`)
      .then(() => {
        const index = drink.volumes.findIndex(a => a.id === volume.id);
        if (index > -1) {
          drink.volumes.splice(index, 1);
        }
      })
      .catch(err => console.warn(err));
  }
};

const getters = {};

function create_volume(drink: Drink, volume: DrinkPriceVolume) {
  return computed<number>({
    get: () => {
      if (volume.ingredients.some(ingredient => !!ingredient.drink_ingredient)) {
        let retVal = 0;
        volume.ingredients.forEach(ingredient => {
          if (ingredient.volume) {
            retVal += ingredient.volume;
          }
        });
        volume._volume = retVal;
        return retVal;
      } else {
        return volume._volume;
      }
    },
    set: val => (volume._volume = val)
  });
}

function create_min_prices(drink: Drink, volume: DrinkPriceVolume, percentage: number) {
  if (drink.cost_price_pro_volume) {
    if (volume.ingredients.every(ingredient => !!ingredient.drink_ingredient)) {
      return computed<number>(() => {
        let retVal = (drink.cost_price_pro_volume || 0) * (volume.volume?.value || 0);
        volume.ingredients.forEach((ingredient: FG.ExtraIngredient) => {
          retVal += ingredient.price;
        });
        retVal = (retVal * percentage) / 100;
        return retVal;
      });
    } else {
      return computed<number>(
        () => ((drink.cost_price_pro_volume || 0) * (volume.volume?.value || 0) * percentage) / 100
      );
    }
  } else {
    return computed<number>(() => {
      let retVal = 0;
      volume.ingredients.forEach(ingredient => {
        if (ingredient.drink_ingredient) {
          retVal += ingredient.volume * (ingredient.drink_ingredient.cost_price_pro_volume || 0);
        }
        if (ingredient.name) {
          retVal += ingredient.price;
        }
      });
      console.log(volume);
      return (retVal * percentage) / 100;
    });
  }
}
export { create_min_prices, create_volume, DrinkPriceVolume, MinPrice, Drink };
export default {
  state,
  actions,
  getters
};