import * as API from 'api/real/orders';

const state = {
  order_group: {}, // 订单组
  real_orders: [], // RD订单
  cards: [], // RD订单卡列表
  relations: [],
  selected: [],
  orderParams: {},
  cardParams: {},
  real_companies: [],
  real_packages: [],
  relationParams: {},
  relationObj: {
    real_company_id: '',
    real_package_id: '',
    virtual_company_id: '',
    virtual_package_id: ''
  }
};

const getters = {
  relations: state => state.relations,
  relationObj: state => state.relationObj,
  orders: state => state.real_orders,
  cards: state => state.cards,
  selected: state => state.selected,
  counts: (state) => {
    if (!state.selected.length) {
      return 0;
    }

    return state.selected.reduce((acc, cur) => {
      return acc + cur.counts;
    }, 0);
  },
  getFilterUsedCards: () => (cards) => {
    return cards.filter(item => item.virtual_order_id === 0);
  },
  getRealOrderById: (state) => (id) => {
    return state.real_orders.find(item => item.id === id);
  },
  getSelectedByOrderId: (state) => (order_id) => {
    if (typeof order_id !== 'object') {
      order_id = [order_id];
    }

    return state.selected.filter(item => {
      return order_id.includes(item.order_id);
    });
  },
  getCardByOderIdAndSim: (state) => (order_id, sim) => {
    return state.selected.find(item => {
      return item.order_id === order_id && item.sim === sim;
    });
  },
  real_companies: (state) => {
    return state.real_orders.map(el => { return el.company_name; }).filter((v, i, s) => { return s.indexOf(v) === i; });
  },
  real_packages: (state) => {
    return state.real_orders.map(el => { return el.package_name; }).filter((v, i, s) => { return s.indexOf(v) === i; });
  }
};

const mutations = {
  SET_ORDER_GROUP(state, data) {
    state.order_group = data;
  },
  SET_REAL_ORDERS(state, data) {
    state.real_orders = data;
  },
  SET_CARDS(state, data) {
    state.cards = data;
  },
  SET_RELATIONS(state, data) {
    state.relations = data;
  },
  SET_RELATION_OBJ(state, obj) {
    state.relationObj = obj;
  },
  SET_RELATION_PARAMS(state, data) {
    state.relationParams = data;
  },
  SET_CARD_PARAMS(state, obj) {
    state.cardParams = obj;
  },
  SET_ORDER_PARAMS(state, obj) {
    state.orderParams = obj;
  },
  PUSH_CARDS(state, cards) {
    state.cards = state.cards.concat(cards.filter(item => {
      return state.cards.findIndex(v => {
        return v.sim === item.sim && v.order_id === item.order_id;
      }) === -1;
    }));
  },
  SET_SELECTED(state, data) {
    state.selected = data;
  },
  PUSH_SELECTED(state, array) {
    let selected = JSON.parse(JSON.stringify(state.selected));

    for (let index = 0; index < array.length; index++) {
      const element = array[index];

      let i = selected.findIndex(item => {
        return item.order_id === element.order_id && item.sim === element.sim;
      });

      if (i !== -1) {
        selected.splice(i, 1);
      }

      let obj = element;

      selected.push(obj);
    }

    state.selected = selected;
  },
  REMOVE_SELECTED(state, array) {
    let selected = state.selected.map(item => {
      return JSON.parse(JSON.stringify(item));
    });

    for (let index = 0; index < array.length; index++) {
      const element = array[index];

      let i = 0;

      while (i !== -1) {
        i = selected.findIndex(item => {
          return element.sim ? (item.order_id === element.order_id && item.sim === element.sim) : (item.order_id === element.order_id);
        });

        if (i !== -1) {
          selected.splice(i, 1);
        }
      }
    }

    state.selected = selected;
  }
};

const actions = {
  initOrder(context) {
    context.commit('SET_RELATION_PARAMS', {});
    context.commit('SET_ORDER_PARAMS', {});
    context.commit('SET_CARD_PARAMS', {});
    context.commit('SET_RELATION_OBJ', {});
    context.commit('SET_ORDER_GROUP', {});
    context.commit('SET_REAL_ORDERS', []);
    context.commit('SET_CARDS', []);
    context.commit('SET_SELECTED', []);
  },
  getRelations(context, params) {
    return new Promise((resolve, reject) => {
      if (JSON.stringify(context.state.relationParams) == JSON.stringify(params)) {
        return resolve(context.state.relations);
      }

      context.commit('SET_RELATION_PARAMS', params);

      API.relations(params).then(res => {
        if (res.code === 0) {
          context.commit('SET_RELATIONS', res.data);
          resolve(res.data);
        } else {
          reject(res);
        }
      }).catch(err => {
        reject(err);
      });
    });
  },
  getOrders(context, params) {
    params.limit = 0;
    return new Promise((resolve, reject) => {
      if (JSON.stringify(context.state.orderParams) == JSON.stringify(params)) {
        return resolve(context.state.real_orders);
      }

      context.commit('SET_ORDER_PARAMS', params);

      API.index(params).then(res => {
        if (res.code === 0) {
          context.commit('SET_REAL_ORDERS', res.data);
          resolve(res.data);
        } else {
          reject(res);
        }
      }).catch(err => {
        reject(err);
      });
    });
  },
  getCards(context, { order_id, type }) {
    return new Promise((resolve, reject) => {
      if (typeof order_id !== 'object') {
        order_id = [order_id];
      }

      let array = [];

      for (let index = 0; index < order_id.length; index++) {
        const id = order_id[index];

        let i = context.state.cards.findIndex(item => {
          return item.order_id === id;
        });

        if (i === -1 && array.indexOf(id) === -1) {
          array.push(id);
        }
      }

      let cards = [];

      if (!array.length) {
        cards = context.state.cards.filter(v => {
          return order_id.indexOf(v.order_id) !== -1;
        });

        return resolve(cards);
      }

      API.cards({ order_id: array, type }).then(res => {
        let index = context.state.cards.length;

        if (res.code === 0) {
          let data = res.data;

          data.map(row => {
            row._index = index++;
          });

          context.commit('PUSH_CARDS', data);

          let cards = context.state.cards.filter(v => {
            return order_id.indexOf(v.order_id) !== -1;
          });
          resolve(cards);
        } else {
          reject(res);
        }
      }).catch(err => {
        reject(err);
      });
    });
  },
  getCardsByParams(context, params) {
    return new Promise((resolve, reject) => {
      API.cards(params).then(res => {
        if (res.code === 0) {
          context.commit('PUSH_CARDS', res.data);
          resolve(res.data);
        } else {
          reject(res);
        }
      }).catch(err => {
        reject(err);
      });
    });
  }
};

export default {
  state,
  getters,
  mutations,
  actions
};