package controller

import (
	"fmt"

	"git.rosy.net.cn/baseapi"
	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/globals"
	"git.rosy.net.cn/jx-callback/legacy/models"
	"github.com/astaxie/beego/orm"
)

const (
	OrderStatusApplyUrgeOrder = -15
	OrderStatusApplyRefund    = -10
	OrderStatusApplyCancel    = -5

	OrderStatusUnknown = 0

	OrderStatusNew            = 5  // 新定单
	OrderStatusAdjust         = 8  // 定单调整
	OrderStatusAccepted       = 10 // 已经接单，也即待出库，待拣货
	OrderStatusFinishedPickup = 15 // 拣货完成
	OrderStatusDelivering     = 20 // 开始配送，配送员已取货，从这里开始就是运单消息了

	OrderStatusEndBegin  = 100 // 以上的状态就是结束状态
	OrderStatusDelivered = 105 // 妥投
	OrderStatusFinished  = 110 // 定单已完成
	OrderStatusCanceled  = 115 // 定单已取消
	OrderStatusFailed    = 120 // 定单已失败
)

const (
	LockStatusUnlocked = 0
	LockStatusLocked   = 1
)

type PurchasePlatformHandler interface {
	AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptIt bool)
}

type DeliveryPlatformHandler interface {
	DeliveryProvider
}

type OrderController struct {
	orderMap                 SyncMapWithTimeout
	purchasePlatformHandlers map[int]PurchasePlatformHandler
	deliveryPlatformHandlers map[int]DeliveryPlatformHandler
}

func NewOrderManager() *OrderController {
	return &OrderController{
		purchasePlatformHandlers: make(map[int]PurchasePlatformHandler),
		deliveryPlatformHandlers: make(map[int]DeliveryPlatformHandler),
	}
}

func (c *OrderController) RegisterPurchasePlatform(vendorID int, handler PurchasePlatformHandler) {
	if !(vendorID >= VendorIDPurchaseBegin && vendorID <= VendorIDPurchaseEnd) {
		panic(fmt.Sprintf("purchase vendor:%d is illegal", vendorID))
	}
	if _, ok := c.purchasePlatformHandlers[vendorID]; ok {
		panic(fmt.Sprintf("purchase vendor:%d, already exists", vendorID))
	}
	c.purchasePlatformHandlers[vendorID] = handler
}

func (c *OrderController) RegisterDeliveryPlatform(vendorID int, handler DeliveryPlatformHandler) {
	if !(vendorID >= VendorIDDeliveryBegin && vendorID <= VendorIDDeliveryEnd) {
		panic(fmt.Sprintf("delivery vendor:%d is illegal", vendorID))
	}
	if _, ok := c.deliveryPlatformHandlers[vendorID]; ok {
		panic(fmt.Sprintf("delivery vendor:%d, already exists", vendorID))
	}
	c.deliveryPlatformHandlers[vendorID] = handler
}

func (c *OrderController) OnOrderNew(order *model.GoodsOrder, orderSkus []*model.OrderSku) (err error) {
	db := orm.NewOrm()
	order.Status = OrderStatusNew
	isDuplicated, err := addOrderOrWaybillStatus(c.order2Status(order), db)
	if !isDuplicated {
		c.handleAutoAcceptOrder(order.VendorOrderID, order.VendorID, order.ConsigneeMobile, order.StoreID, db, func(isAccept bool) {
			// c.purchasePlatformHandlers[order.VendorID].AcceptOrRefuseOrder(order, isAccept)
			if isAccept {
				order.Status = OrderStatusAccepted
			} else {
				order.Status = OrderStatusFailed
			}
		})

		err = c.updateOrderOtherInfo(order, db)
		if err == nil {
			err = c.updateOrderSkuOtherInfo(orderSkus, db)
			if err == nil {
				db.Begin()
				// globals.SugarLogger.Debugf("new order:%v", order)
				order.OrderFinishedAt = DefaultTimeValue
				order.ID = 0
				created, _, err2 := db.ReadOrCreate(order, "VendorOrderID", "VendorID")
				err = err2
				if err == nil {
					c.orderMap.Store(ComposeUniversalOrderID(order.VendorOrderID, order.VendorID), order.ID)
					if created {
						sql := "INSERT INTO order_sku(vendor_order_id, vendor_id, count, sku_id, vendor_sku_id, sku_name, shop_price, sale_price, weight, order_created_at) VALUES"
						params := []interface{}{}
						for _, sku := range orderSkus {
							sql += "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?),"
							params = append(params, sku.VendorOrderID, sku.VendorID, sku.Count, sku.SkuID, sku.VendorSkuID, sku.SkuName, sku.ShopPrice, sku.SalePrice, order.Weight, order.OrderCreatedAt)
						}
						sql = sql[:len(sql)-1] + ";"
						_, err = db.Raw(sql, params...).Exec()
						if err != nil {
							db.Rollback()
							baseapi.SugarLogger.Infof("insert order_sku error:%v", err)
						} else {
							db.Commit()
						}
					} else {
						order.DuplicatedCount++
						db.Update(order, "DuplicatedCount")
						db.Commit()
						baseapi.SugarLogger.Infof("duplicated order:%s vendorID:%d, msg received", order.VendorOrderID, order.VendorID)
					}
				} else {
					db.Rollback()
					globals.SugarLogger.Warnf("create order:%v, error:%v", order, err)
				}
			}
		}
	}
	return err
}

func (c *OrderController) OnOrderAdjust(order *model.GoodsOrder, orderSkus []*model.OrderSku) (err error) {
	db := orm.NewOrm()
	order.Status = OrderStatusAdjust
	if isDuplicated, err := addOrderOrWaybillStatus(c.order2Status(order), db); err == nil && !isDuplicated {
		err = utils.CallFuncLogError(func() error {
			_, err := db.Raw("DELETE FROM order_sku WHERE vendor_order_id = ? AND vendor_id = ?", order.VendorOrderID, order.VendorID).Exec()
			return err
		}, "OnAdjustOrder delete order")
		if err != nil {
			return err
		}

		err = utils.CallFuncLogError(func() error {
			_, err := db.Raw("DELETE FROM goods_order WHERE vendor_order_id = ? AND vendor_id = ?", order.VendorOrderID, order.VendorID).Exec()
			return err
		}, "OnAdjustOrder delete order_sku")
		if err != nil {
			return err
		}
	}
	return c.OnOrderNew(order, orderSkus)
}

func (c *OrderController) OnOrderStatusChanged(orderStatus *model.OrderStatus) (err error) {
	if isDuplicated, err := c.addOrderStatus(orderStatus, nil); err == nil && !isDuplicated {
	}
	return err
}

// private
func (c *OrderController) updateOrderSkuOtherInfo(orderSkus []*model.OrderSku, db orm.Ormer) (err error) {
	return nil
}

func (c *OrderController) updateOrderOtherInfo(order *model.GoodsOrder, db orm.Ormer) (err error) {
	return nil
}

func (c *OrderController) handleAutoAcceptOrder(orderID string, vendorID int, userMobile string, jxStoreID int, db orm.Ormer, handler func(accepted bool)) int {
	handleType := 0
	if userMobile != "" {
		if db == nil {
			db = orm.NewOrm()
		}
		user := &models.BlackClient{
			Mobile: userMobile,
		}
		if err := db.Read(user, "Mobile"); err != nil {
			if err != orm.ErrNoRows {
				globals.SugarLogger.Errorf("read data error:%v, data:%v, vendorID:%d", err, user, vendorID)
			}
			// 在访问数据库出错的情况下，也需要自动接单
			handleType = 1
		} else {
			// 强制拒单
			globals.SugarLogger.Infof("force reject order:%s, vendorID:%d", orderID, vendorID)
			handleType = -1
		}
	} else {
		globals.SugarLogger.Infof("order:%s, vendorID:%d, mobile is empty, should accept it", orderID, vendorID)
		handleType = 1
	}

	if handleType == 1 {
		handler(true)
	} else if handleType == -1 {
		handler(false)
	}
	return handleType
}

func (c *OrderController) addOrderStatus(orderStatus *model.OrderStatus, db orm.Ormer) (isDuplicated bool, err error) {
	if db == nil {
		db = orm.NewOrm()
	}
	isDuplicated, err = addOrderOrWaybillStatus(orderStatus, db)
	if !isDuplicated && orderStatus.Status > OrderStatusUnknown {
		order := &model.GoodsOrder{
			VendorOrderID: orderStatus.VendorOrderID,
			VendorID:      orderStatus.VendorID,
		}
		if err = c.updateOrderPKID(order, db); err == nil {
			order.Status = orderStatus.Status
			order.VendorStatus = orderStatus.VendorStatus
			utils.CallFuncLogError(func() error {
				columns := []string{"Status", "VendorStatus"}
				if orderStatus.Status >= OrderStatusDelivered {
					order.OrderFinishedAt = orderStatus.StatusTime
					columns = append(columns, "OrderFinishedAt")
				}
				_, err := db.Update(order, columns...)
				return err
			}, "update order")
		}
	}
	return isDuplicated, err
}

func (c *OrderController) updateOrderPKID(order *model.GoodsOrder, db orm.Ormer) (err error) {
	value, ok := c.orderMap.Load(ComposeUniversalOrderID(order.VendorOrderID, order.VendorID))
	if !ok {
		err = db.Read(order, "VendorOrderID", "VendorID")
		// todo 这里应该要报警，但测试阶段先去掉
		// utils.CallFuncLogError(func() error {
		// 	err = db.Read(order, "VendorOrderID", "VendorID")
		// 	return err
		// }, "can not get order info from db")
	} else {
		order.ID = value.(int64)
	}
	return err
}

func (c *OrderController) order2Status(order *model.GoodsOrder) (retVal *model.OrderStatus) {
	retVal = &model.OrderStatus{
		VendorOrderID: order.VendorOrderID,
		VendorID:      order.VendorID,
		OrderType:     OrderTypeOrder,
		Status:        order.Status,
		VendorStatus:  order.VendorStatus,
		StatusTime:    order.OrderCreatedAt,
	}
	return retVal
}

//Waybill

func (c *OrderController) OnWaybillStatusChanged(bill *model.Waybill, db orm.Ormer) (err error) {
	return c.updateOrderByWaybill(bill, db)
}

func (c *OrderController) updateOrderByWaybill(bill *model.Waybill, db orm.Ormer) (err error) {
	if db == nil {
		db = orm.NewOrm()
	}
	order := &model.GoodsOrder{
		VendorOrderID: bill.VendorOrderID,
		VendorID:      bill.OrderVendorID,
	}
	if err = db.Read(order, "VendorOrderID", "VendorID"); err == nil {
		if order.Status < OrderStatusEndBegin {
			order.WaybillStatus = bill.Status
			order.WaybillVendorStatus = bill.VendorStatus
			db.Update(order, "WaybillStatus", "WaybillVendorStatus")
		}
	}
	return err
}