'use strict';

const api = global.yoho.API;
const camelCase = global.yoho.camelCase;
const moment = require('moment');

const _ = require('lodash');

const pageSize = 10;

// 订单列表类型对应的导航下标
const typeActiveIndexMap = {
    1: 0,
    2: 1,
    3: 2
};

const paymentTypeStr = {
    1: '在线支付',
    2: '货到付款',
    3: '现金支付',
    4: '抵消支付'
};

const btnMap = {
    all: [
        {
            name: '立即付款',
            classStr: 'btn red pay-btn mr'
        },
        {
            name: '修改订单',
            classStr: 'btn white edit-btn mr'
        },
        {
            name: '取消订单',
            classStr: 'btn white cancel-btn'
        }
    ],
    cancel: [
        {
            name: '取消订单',
            classStr: 'btn white cancel-btn'
        }
    ],
    edit: [
        {
            name: '修改订单',
            classStr: 'btn white edit-btn'
        }
    ],
    complete: [
        {
            name: '确认收货',
            classStr: 'btn complete-btn'
        }
    ],
    special: [
        {
            name: '修改订单',
            classStr: 'btn white edit-btn mr'
        },
        {
            name: '取消订单',
            classStr: 'btn white cancel-btn'
        }
    ]
};

const invoiceText = {
    1: '纸质',
    2: '电子'
};


// 订单状态
const statusMap = {
    0: {
        value: 0,
        valueStr: '待付款',
        step: 1,
        btns: btnMap.all
    },
    1: {
        value: 1,
        valueStr: '备货中',
        step: 1,
        btns: btnMap.edit
    },
    2: {
        value: 1,
        valueStr: '备货中',
        step: 1,
        btns: btnMap.edit
    },
    3: {
        value: 1,
        valueStr: '备货中',
        step: 1,
        btns: btnMap.edit
    },
    4: {
        value: 2,
        valueStr: '待收货',
        step: 3,
        showGetBtn: true,
        btns: btnMap.complete
    },
    5: {
        value: 2,
        valueStr: '待收货',
        step: 3,
        showGetBtn: true,
        btns: btnMap.complete
    },
    6: {
        value: 3,
        valueStr: '交易完成',
        step: 4,
        showEditor: true
    }
};

// 订单类型为手机的订单
const isMobileOrder = {
    3: true,
    4: true,
    6: true
};

// const _removeRmbIcon = str => {
//     return str.replace('¥', '');
// }

// 转换时间戳
const _convertUnixTime = src => {
    return moment.unix(src).format('YYYY-MM-DD hh:mm:ss');
};

const _convertAddress = (addressList, createTime) => {
    let addrList = [];

    addressList.forEach(addr => {
        let address = {
            time: '',
            city: '',
            action: ''
        };

        address.time = addr.acceptTime;
        addr = addr.acceptAddress.split(' ');

        if (addr.length > 1 && /市/.test(addr[0])) {
            address.city = addr[0].replace('市', '');
            addr.splice(0, 1);
            address.action = addr.join('');
        } else {
            address.action = addr.join('');
        }


        addrList.push(address);
    });

    // 增加一个默认初始状态
    addrList.push({
        time: createTime,
        action: '您的订单已提交，等待付款'
    });

    return _.reverse(addrList);
};

// 根据订单状态获取当前步骤
const _getStepByOrderStatus = st => {
    let steps = [
        {
            stepStr: '1.提交订单'
        },
        {
            stepStr: '2.商品出库'
        },
        {
            stepStr: '3.等待收货'
        },
        {
            stepStr: '4.交易完成'
        }
    ];
    let curStep = statusMap[st].step;

    for (let i = 0; i < curStep; i++) {
        steps[i].isActive = true;
    }

    // 最后一个激活步骤需要特殊处理样式
    steps[curStep - 1].isLastActive = true;

    return steps;
};

const _getDetail = (uid, code) => {
    return api.get('', {
        method: 'app.SpaceOrders.detail',
        uid: uid,
        order_code: code
    }, {
        cache: true
    });
};

const _getUserOrder = (uid, type, page) => {

    return api.get('', {
        method: 'app.SpaceOrders.get',
        uid: uid,
        type: type,
        page: page,
        limit: pageSize
    }).then(result => {
        let orderList = [];
        let total = false;
        let curPage = 1;

        if (result && result.data) {
            orderList = camelCase(result.data.order_list);
            total = result.data.total;
            curPage = result.data.page;
        }

        orderList.forEach(item => {
            const ot = parseInt(item.orderType, 10);
            const st = parseInt(item.status, 10);

            // 转换订单创建时间
            item.createTime = _convertUnixTime(item.createTime);

            // 没有取消订单并且状态为0的时候显示付款按钮
            if (item.isCancel === 'N' &&
                st === 0) {
                item.showPayButton = true;
            }

            // 具体订单类型见 http://git.yoho.cn/yoho-documents/api-interfaces/blob/master/%E8%AE%A2%E5%8D%95/order.md
            // 判断是否是手机订单，3, 4, 6对应 iOS, Android, H5
            item.showMobile = isMobileOrder[ot];

            // 判断是否展示编辑选项
            item.showEditOption = statusMap[st].showEditor;

            // 判断是否是待收货状态
            item.showGetBtn = statusMap[st].showGetBtn;

            // 在线支付和货到付款有按钮的差异
            item.isOnlinePaid = parseInt(item.paymentType, 10) === 1;


            if (item.isCancel === 'Y') {
                item.showBuyBtn = true;
                item.statusStr = '已取消';
            } else if (item.isOnlinePaid) {
                item.statusStr = statusMap[st].valueStr;
            }

        });

        return {
            orderList: orderList,
            total: total,
            curPage: curPage
        };
    });
};


const deleteOrder = (uid, code) => {
    return api.get('', {
        method: 'app.SpaceOrders.delOrderByCode',
        uid: uid,
        order_code: code
    }, {
        cache: true
    });
};

const cancelOrder = (uid, data) => {
    return api.get('', {
        method: 'app.SpaceOrders.close',
        uid: uid,
        order_code: data.orderCode,
        reason_id: data.reasonId,
        reason: data.reason
    }, {
        cache: true
    });
};

const getCancelOrderReason = () => {
    return api.get('', {
        method: 'app.SpaceOrders.closeReasons'
    }, {
        cache: true
    });
};

const getExpressInfo = (uid, code) => {
    return api.get('', {
        method: 'app.express.get',
        uid: uid,
        order_code: code
    }, {
        cache: true
    });
};

const getOrderData = (uid, type, page) => {
    const navBar = {
        tabs: [
            {
                text: '全部订单',
                typeStr: 'all'
            },
            {
                text: '待付款',
                typeStr: 'paying'
            },
            {
                text: '待发货',
                typeStr: 'delivering'
            }
        ]
    };

    const emptyMsg = {
        1: {
            text: '您暂时还没有订单',
            showEmptyEn: true
        },
        2: {
            text: '您暂时还没有待付款的订单'
        },
        3: {
            text: '您暂时还没有待收货的订单'
        }
    };

    type = parseInt(type, 10);

    type = type < 4 ? type : 1;
    page = page || 1;


    return _getUserOrder(uid, type, page).then(result => {
        const basicData = {
            title: '我的订单',
            showSearch: false, // type === 1,
            total: result.total,
            type: type
        };

        const empty = {
            showEmptyEn: emptyMsg[type].showEmptyEn,
            emptyMsg: emptyMsg[type].text
        };

        navBar.tabs[typeActiveIndexMap[type]].isActive = true;

        const order = Object.assign(basicData, {
            orderList: result.orderList.length && result.orderList || false
        }, navBar);

        const paginationOpts = result.total > pageSize ? {
            paginationOpts: {
                total: result.total,
                page: result.curPage,
                limit: pageSize
            }
        } : false;

        return {
            order: Object.assign(order, paginationOpts, empty)
        };
    });
};

const getOrderDetail = (uid, code) => {
    return api.all([_getDetail(uid, code), getExpressInfo(uid, code)]).then(result => {
        let detail = result[0] && camelCase(result[0].data);
        let express = result[1] && camelCase(result[1].data);

        const st = parseInt(detail.status, 10);

        const basicData = {
            title: '订单详情'
        };

        detail.createTime = _convertUnixTime(detail.createTime);

        if (detail.isCancel === 'N' &&
            st === 0) {
            detail.showLeftTime = true;
        }

        // 需要和接口确认如何获取运费，接口文档和线上数据不一致
        // if (detail.shippingCost) {
        //     detail.shippingCost = _removeRmbIcon(detail.shippingCost);
        // } else if (detail.promotionFormulas) {
        //     detail.promotionFormulas.forEach(d => {
        //         if (d.promotion === '运费') {
        //             detail.shippingCost = _removeRmbIcon(d.promotionAmount);
        //         }
        //     });
        // }


        if (st !== 0 && detail.isCancel !== 'Y') {
            detail.showPaid = true;
        }

        if (detail.isCancel !== 'Y') {
            detail.steps = _getStepByOrderStatus(st);
            detail.btns = statusMap[st].btns;

            if (parseInt(detail.paymentType, 10) === 2 &&
                (statusMap[st].valueStr === '备货中' ||
                 detail.statusStr === '备货中')) {
                detail.btns = btnMap.special;
            }
        }

        if (detail.invoice) {
            detail.invoice.typeText = invoiceText[detail.invoice.type];
        }

        detail.paymentTypeStr = paymentTypeStr[detail.paymentType];

        detail.expressInfo = express;
        detail.expressInfo.addressList = _convertAddress(express.expressDetail, detail.createTime);

        return {
            orderDetail: Object.assign(basicData, detail)
        };

    });
};

const editOrder = data => {
    return api.get('', {
        method: 'app.SpaceOrders.updateDeliveryAddress',
        uid: data.uid,
        order_code: data.orderCode,
        user_name: data.userName,
        area_code: data.areaCode,
        address: data.address,
        mobile: data.mobile,
        phone: data.phone
    }, {
        cache: true
    });
};

const reAddCart = (uid, code) => {
    return api.get('', {
        method: 'app.Shopping.readd',
        uid: uid,
        order_code: code
    }, {
        cache: true
    });
};

module.exports = {
    getOrderData: getOrderData,
    getOrderDetail: getOrderDetail,
    cancelOrder: cancelOrder,
    getCancelOrderReason: getCancelOrderReason,
    deleteOrder: deleteOrder,
    editOrder: editOrder,
    getExpressInfo: getExpressInfo,
    reAddCart: reAddCart
};