'use strict';


const api = global.yoho.API;
const serviceApi = global.yoho.ServiceAPI;

const _ = require('lodash');

// const config = global.yoho.config;
const helpers = global.yoho.helpers;
const camelCase = global.yoho.camelCase;
const logger = global.yoho.logger;

const CODE_LOGISTIC_BANNER = '1fc9b2484fcd559049f2f7e0db313f20'; // 物流详情banner资源码

const closeReasons = () => {
    return api.get('', {
        method: 'app.SpaceOrders.closeReasons'
    }, {
        cache: true
    }).then((result) => {
        if (result && result.code === 200) {
            return result.data;
        } else {
            return {};
        }
    });
};

/**
 * 获取快递有关信息
 * @private
 */
const _assignExpressInfo = (showLogistics, order) => {
    let data = {};

    if (showLogistics && order.expressCompany && order.expressCompany.caption) {
        data = {
            logisticsUrl: helpers.urlFormat('/home/logistic', {order_code: order.orderCode}),
            logisticsCompany: order.expressCompany.caption,
            logisticsNum: order.expressNumber || ''
        };
    }

    return data;
};

/**
 * 获取订单状态
 * @private
 */
const _getOrderStatus = (order, showLogistics) => {
    let result = {};

    if (order.isCancel === 'Y') {
        return {
            canceled: true
        };
    }

    order.status = parseInt(order.status, 10);

    // 先判断订单付款方式，根据不同的付款方式计算订单状态。（注:货到付款没有待付款状态）
    // 支付方式为非货到付款时，计算订单状态。
    if (parseInt(order.paymentType, 10) !== 2) {
        Object.assign(result, {
            isPayonline: true
        });

        let isPayaly = order.paymentName === '' ? false : true;

        switch (order.status) {
            case 0:

                /* 待付款 */
                Object.assign(result, {
                    unpaid: true,
                    payUrl: helpers.urlFormat('/home/orders/paynew', {order_code: order.orderCode})
                });
                break;
            case 1:
            case 2:
            case 3:

                /* 已付款状态不给查看物流 URL */
                Object.assign(result, {
                    unreceived: true,
                    payAly: isPayaly
                });
                break;
            case 4:
            case 5:

                /* 已发货状态，给查看物流或二维码URL */
                Object.assign(result, {
                    unreceived: true,
                    payAly: isPayaly
                });

                /* 是否门票 */
                if (order.virtualType && parseInt(order.virtualType, 10) === 3) {
                    Object.assign(result, {
                        qrcode: helpers.urlFormat(`/home/QRcode/${order.orderCode}`)
                    });
                } else {
                    Object.assign(result, _assignExpressInfo(showLogistics, order));
                }
                break;
            case 6:

                /* 已成功订单，给查看物流或二维码URL */
                Object.assign(result, {
                    completed: true,
                    payAly: isPayaly
                });

                /* 是否门票 */
                if (order.virtual_type && parseInt(order.virtual_type, 10) === 3) {
                    Object.assign(result, {
                        qrcode: helpers.urlFormat(`/home/QRcode/${order.orderCode}`)
                    });
                } else {
                    Object.assign(result, _assignExpressInfo(showLogistics, order));
                }
                break;
            default:
                break;
        }
    } else {
        Object.assign(result, {
            payAly: true,
            paymentName: (order.paymentName !== '') ? order.paymentName : '货到付款'
        });

        /* 订单为货到付款订单时，计算订单状态。(货到付款没有待付款状态) */
        switch (order.status) {
            case 0:

                /* 备货中 */
                Object.assign(result, {
                    unpaid: true
                });
                break;
            case 1:
            case 2:
            case 3:

                /* 已付款状态不给查看物流URL */
                Object.assign(result, {
                    unreceived: true
                });
                break;
            case 4:
            case 5:

                /* 待收货状态，给查看物流 url */
                Object.assign(result, {
                    unreceived: true
                });
                Object.assign(result, _assignExpressInfo(showLogistics, order));
                break;
            case 6:

                /* 待收货状态，给查看物流 url */
                Object.assign(result, {
                    completed: true
                });
                Object.assign(result, _assignExpressInfo(showLogistics, order));
                break;
            default:
                break;
        }
    }

    return result;
};


const orderDetailData = (uid, orderCode) => {

    return api.get('', {
        method: 'app.SpaceOrders.detail',
        uid: uid,
        order_code: orderCode
    }).then(result => {

        if (result && result.code === 200) {
            let orderDetail = camelCase(result.data);
            let goods = [];
            let status = _getOrderStatus(orderDetail, true);

            orderDetail = _.assign(orderDetail, status);

            if (orderDetail.virtualType && orderDetail.virtualType === 3) {
                orderDetail = _.assign(orderDetail, {
                    isVirtual: true,
                    mobile: result.data.mobile
                });
            }

            orderDetail = _.assign(orderDetail, {
                addressAll: orderDetail.area + orderDetail.address

                // createTime: date('Y-m-d H:i:s', orderDetail.createTime)
            });

            if (orderDetail.counterFlag && orderDetail.counterFlag === 'Y') {
                orderDetail = _.assign(orderDetail, {
                    leftTime: parseInt(orderDetail.payLefttime, 10) * 1000
                });
            }

            _.forEach(orderDetail.orderGoods, function(data) {
                let obj = {};
                let count = +data.buyNumber;

                obj = _.assign(obj, {
                    thumb: data.goodsImage,
                    name: data.productName,
                    color: data.factoryColorName ? data.factoryColorName : data.colorName,
                    size: data.sizeName,
                    price: data.goodsPrice,
                    count: count
                });

                if (data.goodsType === 'gift') {
                    obj = _.assign(obj, {
                        gift: true
                    });
                } else if (data.goodsType === 'priceGift') {
                    obj = _.assign(obj, {
                        advanceBuy: true
                    });
                }

                if (data.expectArrivalTime) {
                    obj = _.assign(obj, {
                        appearDate: data.expectArrivalTime
                    });
                }

                if (data.productSkn) {
                    obj = _.assign(obj, {
                        link: '/product/' + data.productSkn + '.html' // 商品url改版
                    });
                }

                goods.push(obj);

                orderDetail = _.assign(orderDetail, {
                    orderCount: count
                });

            });

            orderDetail.goods = goods;

            if (orderDetail.paymentStatus === 'Y') {
                orderDetail = _.assign(orderDetail, {
                    isPay: true
                });
            }

            // 判断是否可以修改地址
            if (orderDetail.canUpdateDeliveryAddress === 'Y' && orderDetail.isSupportChangeProvince === 'Y') {
                orderDetail = _.assign(orderDetail, {
                    changeable: true,
                    addressModify: true
                });
            } else if (orderDetail.canUpdateDeliveryAddress === 'Y' && orderDetail.isSupportChangeProvince !== 'Y') {
                orderDetail = _.assign(orderDetail, {
                    changeable: false,
                    addressModify: true
                });
            }

            // 判断是否有关联订单
            if (orderDetail.relateOrderCode === 'Y') {
                orderDetail = _.assign(orderDetail, {
                    relation: true
                });
            } else {
                orderDetail = _.assign(orderDetail, {
                    relation: false
                });
            }

            // 定金预售
            if (orderDetail.attribute * 1 === 9) {
                orderDetail = _.assign(orderDetail, {
                    isDepositAdvance: true
                });
            }

            orderDetail = _.assign(orderDetail, {
                goodsAmount: orderDetail.paymentAmount,
                newUrl: helpers.urlFormat('/home/orders/addressModify', {
                    orderCode: orderCode,
                    areaCode: orderDetail.areaCode
                }),
                url: helpers.urlFormat('/home/addressModify', {
                    orderCode: orderCode,
                    areaCode: orderDetail.areaCode
                })
            });

            // 如果不允许修改省
            if (orderDetail.isSupportChangeProvince !== 'Y') {
                orderDetail.newUrl = orderDetail.newUrl + '&provinceAreaCode=' +
                    _.get(orderDetail, 'deliveryAddress.provinceAreaCode', '');
            }

             // 为支付的拆单配送信息
            if (orderDetail.isMultiPackage && orderDetail.isMultiPackage === 'Y') {
                let jitInfo = {
                    deliveryId: orderDetail.deliveryId,
                    paymentType: orderDetail.paymentType,
                    couponCode: orderDetail.couponCode,
                    yohoCoin: orderDetail.yohoCoin,
                    cartType: 'ordinary'
                };

                orderDetail = _.assign(orderDetail, {
                    isJit: true,
                    jitDetailUrl: helpers.urlFormat('/cart/index/new/jitDetail', jitInfo)
                });
            }

            if (orderDetail.invoice) {
                orderDetail.invoice.type = (orderDetail.invoice.type + '' === '2');
            }

            /* 申请退款 */
            if (_.find(orderDetail.links, o => {
                return o === 'refundApply';
            })) {
                Object.assign(orderDetail, {
                    refundApply: true
                });
            }

            return orderDetail;
        } else {
            logger.error('detail info return no 200');
            return {};
        }

    });
};

// 删除订单
const delOrder = (orderCode, uid) => {
    return api.get('', {
        method: 'app.SpaceOrders.delOrderByCode',
        uid: uid,
        order_code: orderCode
    });
};

// 再次购买
const readdData = (orderCode, uid) => {
    return api.get('', {
        method: 'app.Shopping.readd',
        uid: uid,
        order_code: orderCode
    }).then((result) => {
        if (result && result.code === 200) {
            result.message = '商品已重新加入购物车';
        } else if (result.code === '400') {
            result.message = '缺失参数';
        } else {
            result.message = '商品加入购物车失败';
            result.datat = {};
        }

        return result;
    });
};

// 取消订单
const cancelOrder = (orderCode, uid, reasonId, gender, channel, reason) => {


    return api.get('', {
        method: 'app.SpaceOrders.close',
        uid: uid,
        order_code: orderCode,
        reasonId: reasonId,
        reasons: reason,
        gender: gender,
        yh_channel: channel
    });
};

/**
 * 申请退款
 */
const refundApply = (params) => {
    return api.get('', {
        method: 'app.SpaceOrders.refundApply',
        uid: params.uid,
        order_code: params.orderCode,
        reason_id: params.reasonId,
        reason: params.reason
    });
};

/*
* 我的订单-查看物流
* @param int $orderCode 订单号
* @param int $uid 用户ID
* @return array
*/
const _logisticsData = (orderCode, uid) => {
    return api.get('', {
        method: 'app.express.li',
        order_code: orderCode,
        uid: uid
    });
};

/**
 * 获取物流详情页banner
 */
const _getLogisterBanner = () => {
    return serviceApi.get('operations/api/v5/resource/get', {
        content_code: CODE_LOGISTIC_BANNER
    }, {code: 200});
};

/**
 * 查看物流
 *
 * @param int orderCode 订单编号
 * @param int uid 用户ID
 * @return array
 */
const logistics = (orderCode, uid) => {
    return Promise.all([
        _getLogisterBanner(),
        _logisticsData(orderCode, uid),
    ]).then(result => {
        let finalResult = {
            banner: []
        };
        let banners = result[0];
        let logistic = result[1];

        // 获取物流详情页banner
        if (banners && banners.data) {
            _.forEach(banners.data, value => {
                _.forEach(value.data, subValue => {
                    finalResult.banner.push({
                        url: subValue.url,
                        img: subValue.src
                    });
                });
            });
        }

        if (logistic && logistic.data) {
            finalResult.logisticUrl = _.get(logistic, 'data.url', '');
            finalResult.logisticImg = _.get(logistic, 'data.logo', '');
            finalResult.logisticCompany = _.get(logistic, 'data.caption', '');
            finalResult.logisticNumber = _.get(logistic, 'data.express_number', '');
            finalResult.logisticDetail = [];

            _.forEach(_.get(logistic, 'data.express_detail', []), value => {
                finalResult.logisticDetail.push({
                    status: value.accept_address,
                    date: value.acceptTime,
                });
            });

        }

        return finalResult;
    });
};

/**
 * 修改订单地址
 * @param {参数} params
 */
const changeAddress = (params) => {
    let apiParams = {
        method: 'app.SpaceOrders.updateDeliveryAddress',
        order_code: params.orderCode,
        uid: params.uid,
        user_name: params.username,
        area_code: params.areaCode,
        address: params.address,
        mobile: params.mobile
    };

    if (params.addressId) {
        Object.assign(apiParams, {
            address_id: params.addressId
        });
    }

    if (params.phone) {
        Object.assign(apiParams, {
            phone: params.phone
        });
    }

    return api.post('', apiParams);
};

module.exports = {
    orderDetailData,
    closeReasons,
    delOrder,
    readdData,
    cancelOrder,
    refundApply,
    logistics,
    changeAddress
};