/**
 *  个人中心 退换货
 *  @author chenxuan <xuan.chen@yoho.cn>
 */

'use strict';

const _ = require('lodash');
const Promise = require('bluebird');
const ReturnAPI = require('./returns-api');
const OrdersAPI = require('./orders-api');

const pager = require(`${global.utils}/pager`).setPager;
const co = Promise.coroutine;
const helpers = global.yoho.helpers;

// 常量
const REFUND = 1; // 退货
const EXCHANGE = 2; // 换货
const TRUE = 'Y';
const RETURNS_EMPTY = '您没有退/换货订单';
const CANCEL_REFUND_URI = '/home/returns/cancelRefund';
const CANCEL_EXCHANGE_URI = '/home/returns/cancelChange';
const REFUND_URI = '/home/returns/refundDetail';
const EXCHANGE_URI = '/home/returns/exchangeDetail';

// 处理退换货商品链接
const getProductUrlBySkc = (skn) => {
    return helpers.getUrlBySkc(skn);
};

/**
 * 转换价格
 *
 * @param float|string $price 价格
 * @return float|string 转换之后的价格
 */
const transPrice = (price) => {
    return price ? (price * 1).toFixed(2) : '0.00';
};

module.exports = class extends global.yoho.BaseModel {
    constructor(ctx) {
        super(ctx);
    }

    setDetailGoods(list) {
        let resData = [];
        let goods;

        _.forEach(list, value => {

            goods = {
                href: getProductUrlBySkc(value.product_skn),
                thumb: helpers.image(value.goods_image, 60, 60),
                name: value.product_name || '',
                color: value.color_name,
                size: value.size_name,
                yoho_coin_cut_num: value.yoho_coin_cut_num,
                real_pay_price: transPrice(value.real_pay_price),
                price: transPrice(value.sales_price),
                goods_type: value.goods_type,
                reason: value.reason_name
            };

            resData.push(goods);
        });

        return resData;
    }

    // 处理订单商品的数据
    getGoodsData(goods) {
        let arr = [];

        goods.forEach(good => {

            arr.push({
                href: getProductUrlBySkc(good.product_skn),
                thumb: helpers.image(good.goods_image, 60, 60),
                name: good.product_name,
                goods_type: good.goods_type,
                color: good.color_name,
                size: good.size_name
            });
        });

        return arr;
    }

    /**
     * 获得快递列表
     * @return array
     */
    getExpressCompany(expressList) {
        let data = [];

        _.forEach(expressList, function(value) {
            data.push(value);
        });
        data = _.flatten(data);

        return data;
    }

    /**
     * 退换货列表页数据
     * @param  {string} uid   用户 uid
     * @param  {Number} page  当前页数
     * @param  {Number} limit 每页最大条数
     * @return {Object}             Promise
     */
    getReturnsList(uid, page, limit) {
        let that = this;

        return co(function * () {
            page = Number.parseInt(page, 10) || 1;
            limit = Number.parseInt(limit, 10) || 10;

            let obj = {
                orders: [],
                pager: {}
            };
            let response = yield that.post({
                data: {
                    method: 'app.refund.getList',
                    uid: uid,
                    page: page,
                    limit: limit
                }
            });
            let repData = response.data;

            // 处理数据
            if (response.code === 200 && repData && repData.list.length) {
                obj.pager = Object.assign({
                    count: repData.total,
                    curPage: page,
                    totalPages: repData.total_page || 1
                }, pager(repData.total_page, {page: page}));

                repData.list.forEach(item => {
                    let t = {
                        returnId: item.id,
                        orderNum: item.order_code,
                        orderTime: item.order_create_time,
                        returnTime: item.create_time,
                        returnStatus: item.status_name
                    };

                    let canCancel = item.canCancel === TRUE;
                    let isChange, uri = '', cancelUri = '';

                    switch (item.refund_type) {
                        case REFUND:
                            isChange = false;
                            uri = REFUND_URI;
                            cancelUri = CANCEL_REFUND_URI;
                            break;
                        case EXCHANGE:
                            isChange = true;
                            uri = EXCHANGE_URI;
                            cancelUri = CANCEL_EXCHANGE_URI;
                            break;
                        default:
                            break;
                    }

                    Object.assign(t, {
                        isChange: isChange,
                        canCancel: canCancel,
                        canCancelUrl: cancelUri,
                        moreHref: helpers.urlFormat(uri, { id: item.id }),
                        goods: that.getGoodsData(item.goods)
                    });

                    obj.orders.push(t);
                });
            } else {
                obj.empty = RETURNS_EMPTY;
            }

            return obj;
        })();
    }

    /**
     * 退货申请页数据
     * @param $orderCode
     * @param $uid
     * @return array|mixed
     */
    getOrderRefund(orderCode, uid) {
        let returnApiModel = new ReturnAPI(this.ctx);
        let process = function*() {
            let resData = {};
            let result = yield returnApiModel.getRefundGoodsAsync(orderCode, uid);

            if (result.data) {
                let goods = [];
                let returnReason = result.data.return_reason,
                    remarks = _.split(_.get(result, 'data.special_notice.remark', ''), '   ', 2); // 使用3个空格拆分


                _.forEach(_.get(result, 'data.goods_list', []), value => {
                    let item = {
                        href: getProductUrlBySkc(value.product_skn),
                        thumb: helpers.image(value.goods_image, 60, 60),
                        name: value.product_name,
                        color: value.factory_color_name,
                        size: value.size_name,
                        price: transPrice(value.last_price),
                        skn: value.product_skn,
                        skc: value.product_skc,
                        sku: value.product_sku,
                        goods_type_id: value.goods_type_id,
                        goods_type: value.goods_type,
                        reason: returnReason
                    };

                    // tar note 为每个特殊商品都添加标识
                    if (value.is_limit_skn === 'Y') {
                        item.isLimitSkn = true;
                        item.specialNoticeBo = {
                            title: _.get(result, 'data.special_notice.title', ''),
                            remark1: remarks[0] || '',
                            remark2: remarks[1] || ''
                        };

                        // tar note 对数组做处理，为不显示的添加 inactive
                        if (_.get(result, 'data.special_return_reason')) {
                            let spReason = _.get(result, 'data.special_return_reason');

                            _.forEach(item.reason, (subVal, subKey) => { // eslint-disable-line
                                if (_.indexOf(spReason, subKey)) {
                                    _.set(item, `reason[${subKey}].inactive`, true);
                                }
                            });
                        }
                    }

                    _.get(value, 'tags', []).forEach((val) => {
                        switch (val) {
                            case 'LRE':
                                _.set(item, 'specialNoticeBo.limit7Day', true);
                                break;
                            case 'L15DE':
                                _.set(item, 'specialNoticeBo.limit15Day', true);
                                break;
                            default:
                                break;
                        }
                    });

                    goods.push(item);

                    // 商品中有鞋类，传给前端标识
                    if (value.hasShoes) {
                        _.set(resData, 'tips.footwear', true);
                    }
                });

                Object.assign(resData, {
                    goods: goods,
                    orderCode: orderCode
                });

                _.forEach(result.data.return_amount_mode, (val, key) => {
                    if (val.is_default === 'Y') {
                        _.set(result, `data.return_amount_mode[${key}].default`, true);
                    }
                });

                resData.returnBankMode = _.get(result, 'data.return_bank_mode', '');
                resData.returnAmountMode = result.data.return_amount_mode;
            }

            return {refund: resData};
        };

        return co(process)();
    }

    /**
     * 提交退货申请
     * @param $orderCode
     * @param $uid
     * @param array $goods
     * @param array $payment
     * @return array|mixed
     */
    saveRefund(req, uid) {
        let that = this;
        let process = function*() {
            let returnApiModel = new ReturnAPI(that.ctx);
            let orderCode = req.body.orderCode,
                goods = req.body.goods,
                payment = req.body.payment;


            if (_.isEmpty(orderCode) || orderCode < 1 ||
                _.isEmpty(goods) || _.isEmpty(payment)) {
                return {
                    code: 203,
                    message: '非法提交'
                };
            }

            // 调用模型提交退货申请
            let order = yield new OrdersAPI(that.ctx).viewOrderData(orderCode, uid);

            if (_.isEmpty(order)) {
                return {
                    code: 403,
                    message: '没有找到该订单'
                };
            }

            // 组装站内信内容
            let title = '您有一笔订单提交退货申请:';
            let content = '您的订单' + orderCode + '申请退货，给您带来不便敬请谅解!请至订单中心查看详情!';

            // 调用接口保存退货申请
            let result = yield returnApiModel.refundSubmit(orderCode, uid, goods, payment);

            if (_.get(result, 'code') === 200) {
                // 退货成功发送站内信
                returnApiModel.sendMessage(uid, title, content);

                result.data.refer = helpers.urlFormat('/home/returns/refundSuccess', {orderCode: orderCode});
            }

            return result;
        };

        return co(process)();
    }

    /**
     * 获取退货详情页数据
     * @param $uid
     * @param $id
     * @return array|mixed
     */
    getRefundDetail(applyId, uid) {
        let that = this;
        let process = function*() {
            let returnApiModel = new ReturnAPI(that.ctx);
            let resData = {};
            let result = yield Promise.all([
                returnApiModel.getRefundDetailAsync(applyId, uid),
                returnApiModel.getExpressCompanyAsync()
            ]);

            if (result[0].data) {
                let data = result[0].data;
                let detail = {
                    isChange: false,
                    returnId: applyId,
                    orderNum: data.source_order_code,
                    nowStatus: data.status_name,
                    applyTime: data.create_time,
                    payMode: data.source_payment_type_desc || '',
                    backMode: data.return_amount_mode_name || '',
                    return_asset_desc: data.return_asset_desc,
                    return_amount: data.return_amount,
                    goods: that.setDetailGoods(data.goods_list)
                };

                if (+data.status !== 0) {
                    detail.express = {
                        id: _.get(data, 'notice.express_id', ''),
                        company: _.get(data, 'notice.express_company', ''),
                        number: _.get(data, 'notice.express_number', ''),
                        title: _.get(data, 'notice.title', ''),
                        titleClass: 'red'
                    };
                }

                detail.statusList = [];
                _.forEach(data.statusList, value => {
                    detail.statusList.push({
                        name: value.name,
                        act: value.act === 'Y'
                    });
                });

                if (data.canCancel === 'Y') {
                    detail.canCancelUrl = '/home/returns/cancelRefund';
                }

                resData.detail = detail;

            }

            if (result[1].data && resData.detail && resData.detail.express) {
                _.set(resData, 'detail.express.expressList', that.getExpressCompany(result[1].data));
            }

            return resData;
        };

        return co(process)();
    }

    /**
     * 获取换货详情页数据
     * @param $uid
     * @param $id
     * @return array|mixed
     */
    getChangeDetail(applyId, uid) {
        let that = this;
        let process = function*() {
            let returnApiModel = new ReturnAPI(that.ctx);
            let resData = {};
            let result = yield Promise.all([
                returnApiModel.getChangeDetailAsync(applyId, uid),
                returnApiModel.getExpressCompanyAsync()
            ]);

            if (result[0].data) {
                let data = result[0].data;
                let detail = {
                    isChange: true,
                    returnId: applyId,
                    orderNum: data.source_order_code,
                    nowStatus: data.status_name,
                    applyTime: data.create_time,
                    goods: that.setDetailGoods(data.goods_list)
                };

                if (+data.status !== 0 && +data.delivery_tpye !== 20) {
                    detail.express = {
                        id: _.get(data, 'notice.express_id', ''),
                        company: _.get(data, 'notice.express_company', ''),
                        number: _.get(data, 'notice.express_number', ''),
                        expressDeadLine: _.get(data, 'notice.date', ''),
                        title: _.get(data, 'notice.title', '')
                    };
                }

                detail.statusList = [];
                _.forEach(data.statusList, value => {
                    detail.statusList.push({
                        name: value.name,
                        act: value.act === 'Y'
                    });
                });

                if (data.canCancel === 'Y') {
                    detail.canCancelUrl = helpers.urlFormat('/home/returns/cancelChange');
                }

                resData.detail = detail;

            }

            if (result[1].data && resData.detail && resData.detail.express) {
                _.set(resData, 'detail.express.expressList', that.getExpressCompany(result[1].data));
            }

            return resData;
        };

        return co(process)();
    }

    /**
     * 提交换货申请
     * @param $orderCode
     * @param $uid
     * @param $goods
     * @param $consigneeName
     * @param $areaCode
     * @param $address
     * @param $mobile
     * @param $zipCode
     * @param $deliveryType
     * @return array|mixed
     */
    saveExchange(req, uid) {
        let that = this;

        let process = function*() {
            let returnApiModel = new ReturnAPI(that.ctx);
            let orderCode = req.body.orderCode,
                goods = req.body.goods,
                consigneeName = req.body.consigneeName,
                areaCode = req.body.areaCode,
                address = req.body.address,
                mobile = req.body.mobile,
                zipCode = req.body.zipCode,
                deliveryType = req.body.deliveryType;

            if (_.isEmpty(orderCode) || orderCode < 1 || _.isEmpty(goods) ||
                _.isEmpty(deliveryType) || _.isEmpty(consigneeName) || _.isEmpty(areaCode) ||
                _.isEmpty(address) || _.isEmpty(mobile)) {
                return {
                    code: 203,
                    message: '非法提交'
                };
            }

            // 调用接口查询订单详情
            let order = yield new OrdersAPI(that.ctx).viewOrderData(orderCode, uid);

            if (_.isEmpty(order)) {
                return {
                    code: 403,
                    message: '没有找到该订单'
                };
            }

            // 订单15天后不能换货
            // if (_.get(order, 'code') === 200) {
            //     if ((new Date() - order.data.create_time) > 15*86400) {
            //         return {
            //             code: 400,
            //             message: '您的订单已经超过了换货有效期'
            //         }
            //     }
            // }

            // 保存换货申请
            let result = yield returnApiModel.exchangeSubmit(orderCode, goods, consigneeName, areaCode,
                address, mobile, zipCode, deliveryType, uid);

            // 组装站内信内容
            let title = '您有一笔订单提交换货申请:';
            let content = '您的订单' + orderCode + '申请换货，给您带来不便敬请谅解!请至订单中心查看详情!';

            // 换货成功，返回前端相应格式，并返回换货成功页跳转链接
            if (_.get(result, 'code') === 200) {
                // 换货成功发送站内信
                returnApiModel.sendMessage(uid, title, content);
                result.data.refer = helpers.urlFormat('/home/returns/exchangeSuccess', {orderCode: orderCode});
            }

            return result;
        };

        return co(process)();
    }

    /**
     * 我的订单，申请换货
     * @param $orderCode
     * @param $uid
     * @return array|mixed
     */
    getOrderExchange(orderCode, uid) {
        let returnApiModel = new ReturnAPI(this.ctx);
        let process = function*() {
            let resData = {};
            let result = yield returnApiModel.getExchangeGoodsAsync(orderCode, uid);

            if (result.data) {
                let goods = [];
                let sknPromise = [];
                let returnReason = result.data.exchange_reason,
                    remarks = _.split(_.get(result, 'data.special_notice.remark', ''), '   ', 2); // 使用3个空格拆分

                _.forEach(_.get(result, 'data.goods_list', []), value => {
                    let item = {
                        href: getProductUrlBySkc(value.product_skn),
                        thumb: helpers.image(value.goods_image, 60, 60),
                        name: value.product_name,
                        color: value.color_name,
                        size: value.size_name,
                        price: value.last_price,
                        skn: value.product_skn,
                        skc: value.product_skc,
                        sku: value.product_sku,
                        goods_type_id: value.goods_type_id,
                        goods_type: value.goods_type,
                        reason: _.cloneDeep(returnReason)
                    };

                    // tar note 为每个特殊商品都添加标识
                    if (value.is_limit_skn === 'Y') {
                        item.isLimitSkn = true;
                        item.specialNoticeBo = {
                            title: _.get(result, 'data.specialNoticeBo.title', ''),
                            remark1: remarks[0] || '',
                            remark2: remarks[1] || ''
                        };

                        let spReason = _.get(result, 'data.special_exchange_reason', []);

                        // tar note 对数组做处理，为不显示的添加 inactive
                        if (spReason && spReason.length) {
                            _.forEach(item.reason, subVal => { // eslint-disable-line
                                if (!_.filter(spReason, ['id', subVal.id]).length) {
                                    subVal.inactive = true;
                                }
                            });
                        }
                    }

                    _.get(value, 'tags', []).forEach((val) => {
                        switch (val) {
                            case 'LRE':
                                _.set(item, 'specialNoticeBo.limit7Day', true);
                                break;
                            case 'L15DE':
                                _.set(item, 'specialNoticeBo.limit15Day', true);
                                break;
                            default:
                                break;
                        }
                    });

                    goods.push(item);

                    // 商品中有鞋类，传给前端标识
                    if (value.hasShoes) {
                        _.set(resData, 'tips.footwear', true);
                    }

                    sknPromise.push(returnApiModel.getProductDataAsync(value.product_skn));
                });

                Object.assign(resData, {
                    orderCode: orderCode,

                    // 换货地址相关数据（邮编为可空参数）
                    name: _.get(result, 'data.address.consignee', ''),
                    area: _.get(result, 'data.address.area', ''),
                    area_code: _.get(result, 'data.address.area_code', ''),
                    address: _.get(result, 'data.address.address', ''),
                    phone: _.get(result, 'data.address.mobile', ''),
                    postcode: _.get(result, 'data.address.zip_code', '')
                });

                let productList = yield Promise.all(sknPromise);

                _.forEach(productList, (product, key) => { // 遍历得到每件商品

                    let colorSize = [],
                        value = product.data;

                    _.forEach(value.goods_list, val => { // 遍历商品得到每个颜色

                        let size = [];

                        _.forEach(val.size_list, v => { // 遍历颜色得到每个尺码
                            if (+v.storage_number > 0) { // 当某个尺码下有库存时，将该颜色及其对应的尺码加入该商品选项下
                                size.push(v);
                            }
                        });

                        if (size.length) {
                            colorSize.push({
                                color: val.factory_goods_name,
                                colorId: val.color_id,
                                goodsId: val.goods_id,
                                skc: val.product_skc,
                                sizeList: size
                            });
                        }
                    });

                    if (colorSize.length) {
                        goods[key].colorSize = colorSize;
                    } else {
                        goods[key].banMsg = '库存不足不能换货';
                    }

                });

                resData.goods = goods;
            }

            return {exchange: resData};
        };

        return co(process)();
    }

    // 获取换货方式
    getDelivery(orderCode, areaCode, uid, skns) {
        return new ReturnAPI(this.ctx).getDeliveryAsync(orderCode, areaCode, uid, _.split(skns, ',')).then(result => {
            if (+result.code === 200) {
                _.remove(result.data, n => {
                    return n.is_support !== 'Y';
                });
            }

            return result;
        });
    }

    // 取消退货申请
    getCancelRefund(id, uid) {
        return new ReturnAPI(this.ctx).cancelRefundAsync(id, uid);
    }

    // 取消换货申请
    getCancelChange(id, uid) {
        return new ReturnAPI(this.ctx).cancelChangeAsync(id, uid);
    }

    // 设置快递
    setExpressNumber(id, expressId, expressNumber, uid, expressCompany, isChange) {
        return new ReturnAPI(this.ctx).setExpressNumberAsync(
            id, expressId, expressNumber, uid, expressCompany, isChange
        );
    }

    // 退货结算
    refundCompute(uid, orderCode, goods) {
        return new ReturnAPI(this.ctx).refundComputeAsync(uid, orderCode, goods);
    }
};