# -*- coding: utf-8 -*-
import copy
import traceback
from collections import OrderedDict
from datetime import datetime
from decimal import Decimal
from .constants import *


__all__ = [
    'CustomOrder',
    'PayReceipt',
    'KitchenOrder'
]


class Item(object):

    def __init__(
        self,
        modeName,
        itemFee,
        giveNum,
        productName,
        amount,
        catalogId,
        productId,
        mark=u'',
        productRemark='',
        *args,
        **kwargs
    ):
        self.mode_name = modeName
        self.item_fee = itemFee
        self.give_num = giveNum
        self.product_name = productName
        self.amount = amount
        self.catalog_id = catalogId
        self.product_id = productId
        self.mark = mark
        self.product_remark = productRemark
        self.oid = u"%s.%s" % (self.product_id, self.mode_name)

    @classmethod
    def from_rows(cls, rows):
        return [cls(**row) for row in rows]

    @property
    def label(self):
        s = u"%s%s" % (self.mark, self.product_name)
        if self.mode_name != u"默认":
            s = u"%s(%s)" % (s, self.mode_name)
        return s


class PrintFields(object):

    def __init__(self, data):
        self.data = data
        #
        self.shop_name = data.get('shopName', '')
        self.is_separated_print = data.get('isSeparatedPrint', False)
        self.print_type = data['printType']
        self.is_reprint = data.get('isReprint', False)
        self.reprint_s = u"(补打)" if self.is_reprint else u''

        self.order = data['order']

        # 下单时间
        self.created_at = self.fmt_timestamp(self.order['createAt']['$date'])
        # 打印时间
        self.printed_at = datetime.now().strftime('%Y-%m-%d %H:%M:%S')

        # 订单编号
        self.order_no = self.order.get('orderNo', '')
        # 订单类型
        self.order_type = self.order.get('orderType', '')
        # 订单类型(文本)
        self.order_type_s = ORDER_TYPE.get(self.order_type, u"")
        # 订单状态
        self.state = self.order.get('state', '')
        # 流水号
        self.today_num = self.order.get('todayNum', 0)

        # 配送信息
        self.address = self.order.get('address', u'')
        self.username = self.order.get('username', u'')
        self.phone = self.order.get('phone', u'')
        self.delivery_begin_at = self.order.get('deliveryBeginAt', None)
        self.delivery_end_at = self.order.get('deliveryEndAt', None)

        # 操作员
        self.operator_name = self.order.get('operatorName', '')
        # 用餐人数
        self.number = self.order.get('number', 0)
        # 台号
        self.table_id = self.order.get('tableId', '')
        self.table_code = self.order.get('tableCode', '')

        # 总数量
        self.total_count = self.order.get('totalCount', 0)
        # 配送费
        self.delivery_fee = self.order.get('deliveryFee', 0)
        # 茶介费
        self.cover_charge = self.order.get('coverCharge', 0)
        # 打包费
        self.pack_fee = self.order.get('packFee', 0)
        # 服务费
        self.tip = self.order.get('tip', 0)
        # 折扣
        self.discount_fee = self.order.get('discountFee', 0)
        self.reduce_fee = self.order.get('reduceFee', 0)
        # 总额
        self.total_fee = self.order.get('totalFee', 0)
        # 实收
        self.real_fee = self.order.get('realFee', 0)
        self.independent_discount = self.order.get('independentDiscount', 0)

        # 会员
        self.is_member = self.order.get('isMember', False)
        self.member_fee = self.order.get('memberFee', 0)
        self.member_discount = self.order.get('memberDiscount', 0)
        self.member_balance = self.order.get('memberBalance', 0)

        # 发票
        self.need_invoice = self.order.get('needInvoice', False)
        self.invoice_title = self.order.get('invoiceTitle', '')

        # 支付方式
        self.pay_type = self.order.get('payType', '')
        # 支付方式(文本)
        self.pay_type_s = PAY_TYPE.get(self.pay_type, u"其他")
        # 支付状态
        self.pay_state = self.order.get('payState', '')
        self.pay_state_s = PAY_STATE.get(self.pay_state, u"未支付")
        # 交易流水
        self.pay_serial_num = self.order.get('paySerialNum', '')
        # 组合支付
        self.combine_pay = self.order.get('combinePay', [])
        self.is_combine_pay = self.order.get('isCombinePay', False)
        # 支付时间
        self.pay_at = self.order.get('payAt', {}).get('$date', None)

        # 备注
        self.remark = self.order.get('remark', '').strip()
        self.more_remark = self.order.get('moreRemark', '').strip()

    def fmt_timestamp(self, ts, format="%Y-%m-%d %H:%M:%S"):
        return datetime.fromtimestamp(ts / 1000).strftime(format)

    def fmt_price(self, price, free_desc=None):
        if (price == 0) and (free_desc is not None):
            return free_desc
        return u"%s元" % str(Decimal(price).quantize(Decimal('.01')))

    @property
    def is_dine_in(self):
        return self.order_type != "TAKE_OUT"

    @property
    def is_origin(self):
        return self.state == "SUBMITTED"

    @property
    def is_modified(self):
        return self.state == "MODIFY_SUBMITTED"

    @property
    def is_cancelled(self):
        return self.state == "CANCELLED"

    def regroup_items(self):
        if self.is_origin or self.is_cancelled:
            return Item.from_rows(rows=self.order['items'])

        if self.is_modified:
            items = Item.from_rows(rows=self.order['items'])
            old_items = Item.from_rows(rows=self.order['oldItems'])

            fn = lambda t: t.oid
            m1 = OrderedDict(zip(map(fn, items), items))
            m2 = OrderedDict(zip(map(fn, old_items), old_items))
            m3 = []

            for product_id, item in m1.items():
                item_old = m2.pop(product_id, None)
                if not item_old:
                    item.mark = u"(加)"
                    m3.append(item)
                else:
                    if item.amount == item_old.amount:
                        if self.is_reprint:
                            m3.append(item)
                    else:
                        if self.is_reprint:
                            m3.append(item_old)
                        item.amount -= item_old.amount
                        item.give_num -= item_old.give_num
                        item.item_fee -= item_old.item_fee
                        item.mark = (
                            u"(加)" if item.amount > 0 else u"(退)")
                        m3.append(item)

            for product_id, item_old in m2.items():
                if self.is_reprint:
                    m3.append(copy.deepcopy(item_old))
                item_old.mark = u"(退)"
                item_old.amount = (-item_old.amount)
                item_old.give_num = (-item_old.give_num)
                item_old.item_fee = (-item_old.item_fee)
                m3.append(item_old)

            return m3

        return []


class CustomOrder(object):

    def __init__(
        self,
        copies_dine_in=0,
        copies_take_out=0,
        is_print_by_table=False,
        table_ids=[],
        *args,
        **kwargs
    ):
        self.copies_dine_in = copies_dine_in
        self.copies_take_out = copies_take_out
        self.is_print_by_table = is_print_by_table
        self.table_ids = table_ids

    def dummy_print(self, fmt, data):
        fmt.table_space = fmt.table_space_m
        fields = PrintFields(data)

        if (
            self.is_print_by_table and
            (fields.table_id not in self.table_ids)
        ):
            return 0x01, None

        if fields.is_dine_in:
            copies = self.copies_dine_in
        else:
            copies = self.copies_take_out

        if fields.is_reprint:
            copies = 1

        if copies == 0:
            return 0x01, None

        order_items = fields.regroup_items()
        if len(order_items) == 0:
            return 0x01, None

        try:
            for i in xrange(copies):
                self.print_head(fmt, fields)
                self.print_body(fmt, fields, order_items)
                self.print_foot(fmt, fields)
            fmt.device.hints()
            return 0x00, fmt.device.export
        except Exception as e:
            traceback.print_exc()
            return 0x09, e

    def print_head(self, fmt, fields):
        fmt.set()
        fmt.print_line(u"操作员：%s" % fields.operator_name)
        fmt.print_line(u"【订单编号：%s】" % fields.order_no)

        fmt.set(align="center", height=2)
        fmt.print_line(u"%s" % fields.shop_name)

        fmt.set(align="center", height=1)
        fmt.print_line(u"%s(%s)" % (fields.order_type_s, fields.pay_state_s))
        fmt.print_symbol('*')

        # 打印客户信息
        if fields.is_dine_in:
            fmt.set(align="center", height=2)
            fmt.print_line(u"流水号：%s%s" % (fields.today_num, fields.reprint_s))
            fmt.set(align="left", height=2)
            fmt.print_line(
                u"桌台：%s(%s位)" % (fields.table_code, fields.number))
            fmt.set()
            fmt.print_line()
            fmt.print_line(u"下单时间：%s" % fields.created_at)
        else:
            fmt.set(align="left", height=2)
            fmt.print_line(u"地址：%s" % fields.address)
            fmt.set()
            fmt.print_line()
            fmt.print_line(u"客户：%s" % fields.username)
            fmt.print_line(u"电话：%s" % fields.phone)
            fmt.print_line(u"下单时间：%s" % fields.created_at)

            # 配送时间要求
            if (
                (fields.delivery_begin_at is not None) and
                (fields.delivery_end_at is not None)
            ):
                arrived_at = "%s -- %s" % (
                    fields.delivery_begin_at,
                    fields.delivery_end_at
                )
            elif fields.delivery_begin_at is not None:
                arrived_at = fields.delivery_begin_at
            elif fields.delivery_end_at is not None:
                arrived_at = fields.delivery_end_at
            else:
                arrived_at = u"未设置"
            fmt.print_line(u"配送时间：%s" % arrived_at)

        fmt.print_line(u"打印时间：%s" % fields.printed_at)
        fmt.set()

    def print_body(self, fmt, fields, order_items):
        # 1/3: 打印表头
        fmt.set()
        fmt.print_symbol('=')
        fmt.print_row(cells=[u"品项", u"数量", u"金额"])
        fmt.print_symbol('-')

        # 2/3: 打印菜品、数量、价格
        fmt.set(height=2)
        for item in order_items:
            diff = item.amount - item.give_num
            if diff:
                fmt.print_row(cells=[
                    item.label,
                    u"%s份" % diff,
                    fields.fmt_price(item.item_fee)
                ])
            if item.give_num != 0:
                fmt.print_row(cells=[
                    item.label,
                    u"%s份" % item.give_num,
                    u"赠送"
                ])

        # 3/3: 打印茶介费、打包费、配送费
        if not (fields.is_modified and not fields.is_reprint):
            fmt.set()
            fmt.print_row(cells=[
                u"茶介费",
                u"%s位" % fields.number,
                fields.fmt_price(fields.cover_charge, u"免")
            ])
            if fields.pack_fee:
                fmt.print_row(cells=[
                    u"打包费",
                    u"",
                    fields.fmt_price(fields.pack_fee, u"免")
                ])
            if fields.delivery_fee:
                fmt.print_row(cells=[
                    u"配送费",
                    u"",
                    fields.fmt_price(fields.delivery_fee, u"免")
                ])

        fmt.set()
        fmt.print_line()
        fmt.print_symbol('-')
        fmt.set()

    def print_foot(self, fmt, fields):
        if not (fields.is_modified and not fields.is_reprint):
            # 1/3: 打印菜单总量、发票信息
            fmt.set()
            if fields.need_invoice:
                fmt.print_line(u"需要发票/收据")
                fmt.print_line(u"抬头名称：%s" % fields.invoice_title)
            fmt.print_line(u"总数量：%s" % fields.total_count)

            # 2/3: 打印费用
            fmt.set(align="right")
            fee_seq = [
                fields.total_fee,
                fields.discount_fee,
                fields.member_fee,
                fields.tip,
                fields.real_fee
            ]
            fee_seq = [fields.fmt_price(fee) for fee in fee_seq]
            fee_seq = fmt.adjust(fee_seq, fill="left")

            fmt.print_line(u"总额：%s" % fee_seq[0])
            fmt.print_line(u"折扣：%s" % fee_seq[1])
            if fields.is_member:
                fmt.print_line(u"会员：%s" % fee_seq[2])
            if fields.tip:
                fmt.print_line(u"服务费：%s" % fee_seq[3])

            fmt.set(align="right", height=2)
            fmt.print_line(u"实收：%s" % fee_seq[4])
            fmt.set(align="right")
            fmt.print_line(u"(%s)" % fields.pay_state_s)

            # 3/3: 打印备注
            remarks = [s for s in (fields.remark, fields.more_remark) if s]
            if remarks:
                fmt.set()
                fmt.print_symbol('*')
                fmt.set(align="left", height=2)
                head = remarks.pop(0)
                fmt.print_line(u"备注：%s" % head)
                for s in remarks:
                    fmt.print_line(u"%s" % s)

        fmt.set(align="center")
        fmt.print_ending()
        fmt.cut()
        fmt.set()


class PayReceipt(object):

    def __init__(
        self,
        is_print_by_table=False,
        table_ids=[],
        *args,
        **kwargs
    ):
        self.is_print_by_table = is_print_by_table
        self.table_ids = table_ids

    def dummy_print(self, fmt, data):
        fmt.table_space = fmt.table_space_r
        fields = PrintFields(data)

        if (
            self.is_print_by_table and
            (fields.table_id not in self.table_ids)
        ):
            return 0x01, None

        try:
            self.print_head(fmt, fields)
            self.print_body(fmt, fields)
            self.print_foot(fmt, fields)
            fmt.device.hints()
            return 0x00, fmt.device.export
        except Exception as e:
            traceback.print_exc()
            return 0x09, e

    def print_head(self, fmt, fields):
        pass

    def print_body(self, fmt, fields):
        fmt.set(align="center", height=2)
        fmt.print_line(u"付款凭证")
        fmt.set()
        fmt.print_symbol('-')

        fmt.set(align="center", height=2)
        fmt.print_line(u"流水号：%s%s" % (fields.today_num, fields.reprint_s))
        fmt.print_line()

        fmt.set()
        fmt.print_line(u"打印时间：%s" % fields.printed_at)
        fmt.print_line(u"操作员：%s" % fields.operator_name)
        fmt.print_line(u"您好，您的商品已支付成功")
        fmt.print_line(u"商户名称：%s" % fields.shop_name)

        # 打印表格
        fmt.set(align="left", height=2)
        fmt.print_row([u"桌号：", fields.table_code])
        fmt.print_row([u"付款金额：", fields.fmt_price(fields.real_fee)])
        fmt.print_row([u"支付方式：", fields.pay_type_s])

        fmt.set()
        if fields.is_combine_pay:
            for v in fields.combine_pay:
                fmt.print_row([
                    u"    %s：" % PAY_TYPE.get(v.get('payType', ''), u"其他"),
                    fields.fmt_price(v.get('amount', 0))
                ])

        fmt.print_row([u"支付时间：", fields.fmt_timestamp(fields.pay_at)])
        fmt.print_row([u"单号：", fields.order_no])
        fmt.print_row([u"交易号：", fields.pay_serial_num])

    def print_foot(self, fmt, fields):
        fmt.set(align="center")
        fmt.print_ending()
        fmt.cut()
        fmt.set()


class KitchenOrder(object):

    def __init__(
        self,
        is_separated=False,
        is_print_by_catalog=False,
        catalog_ids=[],
        *args,
        **kwargs
    ):
        self.is_separated = is_separated
        self.is_print_by_catalog = is_print_by_catalog
        self.catalog_ids = catalog_ids

    def dummy_print(self, fmt, data):
        fields = PrintFields(data)
        order_items = fields.regroup_items()
        fmt.table_space = fmt.table_space_k

        if self.is_print_by_catalog:
            order_items = [
                item for item in order_items
                if item.catalog_id in self.catalog_ids
            ]

        if len(order_items) == 0:
            return 0x01, None

        try:
            if not self.is_separated:
                self.print_head(fmt, fields)
                self.print_body(fmt, fields, order_items)
                self.print_foot(fmt, fields)
            else:
                for item in order_items:
                    self.print_head(fmt, fields)
                    self.print_body(fmt, fields, [item])
                    self.print_foot(fmt, fields)
            fmt.device.hints()
            return 0x00, fmt.device.export
        except Exception as e:
            traceback.print_exc()
            return 0x09, e

    def print_head(self, fmt, fields):
        fmt.set()

        if fields.is_cancelled:
            fmt.set(align="center", width=2, height=2)
            fmt.print_line(u"** 订单取消 **")

        if fields.is_modified:
            fmt.set(align="center", width=2, height=2)
            fmt.print_line(u"** 订单变更 **")

        fmt.set(align="center", height=2)
        fmt.print_line(u"流水号：%s" % fields.today_num)

        fmt.set()
        fmt.print_line(u"操作员：%s" % fields.operator_name)

        fmt.set(align="left", width=2, height=2)
        if fields.is_dine_in:
            fmt.print_line(u"堂食：%s%s" % (fields.table_code, fields.reprint_s))
        else:
            fmt.print_line(u"外卖订单%s" % fields.reprint_s)

        fmt.set()
        fmt.print_line(u"下单时间：%s" % fields.created_at)
        fmt.print_line(u"打印时间：%s" % fields.printed_at)
        fmt.set()

    def print_body(self, fmt, fields, order_items):
        # 1/2 打印表头
        fmt.set()
        fmt.print_symbol('=')
        fmt.print_row(cells=[u"品项", u"数量"])

        # 2/2 打印表体
        fmt.print_symbol('-')
        fmt.set(align="left", width=2, height=2)
        for item in order_items:
            fmt.print_row(cells=[
                item.label,
                u"%s" % item.amount
            ])
            if item.product_remark:
                fmt.print_line(u"备注：%s" % item.product_remark)
        fmt.set()
        fmt.print_symbol('-')
        fmt.set()

    def print_foot(self, fmt, fields):
        # 1/2 打印备注
        fmt.set()
        remarks = [s for s in (fields.remark, fields.more_remark) if s]
        if remarks:
            fmt.set()
            fmt.print_symbol('*')
            fmt.set(align="left", height=2)
            head = remarks.pop(0)
            fmt.print_line(u"备注：%s" % head)
            for s in remarks:
                fmt.print_line(u"%s" % s)

        # 2/2 打印台号
        fmt.set(align="left", width=2, height=2)
        if fields.is_dine_in:
            fmt.print_line(u"堂食：%s%s" % (fields.table_code, fields.reprint_s))
        else:
            fmt.print_line(u"外卖订单%s" % fields.reprint_s)

        fmt.set(align="center")
        fmt.print_ending()
        fmt.cut()
        fmt.set()