package controller

import (
	"strings"
	"time"

	"git.rosy.net.cn/baseapi"
	"git.rosy.net.cn/baseapi/platformapi/elmapi"
	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/globals"
	"git.rosy.net.cn/jx-callback/globals/api"
	"git.rosy.net.cn/jx-callback/legacy"
	"git.rosy.net.cn/jx-callback/legacy/controllers"
	"git.rosy.net.cn/jx-callback/legacy/elm/models"
	"git.rosy.net.cn/jx-callback/legacy/freshfood"
	"github.com/astaxie/beego/orm"
)

var (
	errResponseInternal        = &elmapi.CallbackResponse{Message: "internal error"}
	errResponseDataError       = &elmapi.CallbackResponse{Message: "elm data error"}
	errResponseDBError         = &elmapi.CallbackResponse{Message: "DB error"}
	errResponseCallELMAPIError = &elmapi.CallbackResponse{Message: "call ELM API error"}
)

type OrderController struct {
}

func (o *OrderController) OrderMessage(msg *elmapi.CallbackMsg) (retVal *elmapi.CallbackResponse) {
	var innerMsg map[string]interface{}
	err := utils.UnmarshalUseNumber([]byte(msg.Message), &innerMsg)
	if err != nil {
		return errResponseDataError
	}

	retVal = elmapi.SuccessResponse
	orderID := innerMsg["orderId"].(string)
	legacy.RoutinePool.CallFun(func() {
		if msg.Type == elmapi.MsgTypeOrderValid {
			userMobile := ""
			if phoneList, ok := innerMsg["phoneList"].([]interface{}); ok && len(phoneList) >= 1 {
				userMobile = phoneList[0].(string)
			} else {
				baseapi.SugarLogger.Warnf("elm can not get mobile info from %v, error:%v", msg, err)
			}
			retVal = o.NewOrder(msg, orderID, userMobile)
		} else if msg.Type >= elmapi.MsgTypeOrderAccepted && msg.Type <= elmapi.MsgTypeOrderFinished {
			retVal = o.OrderStatusChanged(msg, orderID, innerMsg)
		} else {
			retVal = o.OrderOtherMsg(msg, orderID, innerMsg)
		}
	}, orderID)

	return retVal
}

func OnNewOrder(orderID string, userMobile string) {
	controllers.OnNewOrder(orderID, controllers.ELM_VENDORID, userMobile, 0, nil, func(acceptIt bool) {
		if acceptIt {
			time.AfterFunc(4*time.Minute, func() {
				api.ElmAPI.ConfirmOrder(orderID)
			})
		} else {
			api.ElmAPI.CancelOrder(orderID, elmapi.CancelOrderTypeOthers, "")
		}
	})
}

func (o *OrderController) NewOrder(msg *elmapi.CallbackMsg, orderId string, userMobile string) *elmapi.CallbackResponse {
	db := orm.NewOrm()
	rec := &models.ELMOrder{
		OrderId: orderId,
		Type:    msg.Type,
	}

	retVal := elmapi.SuccessResponse
	created, _, err := db.ReadOrCreate(rec, "OrderId")
	if err != nil {
		globals.SugarLogger.Warnf("error when calling ReadOrCreate, error:%v, rec:%v", err, rec)
		retVal = errResponseDBError
	} else {
		if created || rec.Type < msg.Type {
			// todo 回调消息里已经有详情，这里是否有必要再取一次？
			result, err := api.ElmAPI.GetOrder(orderId)
			if err != nil {
				retVal = errResponseCallELMAPIError
			} else {
				rec.Data = string(utils.MustMarshal(result))
				rec.Consignee = result["consignee"].(string)
				rec.Mobile = userMobile
				if createdAt, ok := result["createdAt"].(string); ok {
					rec.OrderCreatedAt = strings.Replace(createdAt, "T", " ", 1)
				}
				num, err := db.Update(rec, "Data", "Consignee", "Mobile", "OrderCreatedAt")
				if err != nil || num != 1 {
					globals.SugarLogger.Warnf("error in updating order data:%v, error:%v, num:%d", msg, err, num)
					retVal = errResponseDataError
				} else {
					err = freshfood.FreshFoodAPI.NewELMOrder(result)
					if err != nil {
						retVal = errResponseInternal
					}
				}
			}
			OnNewOrder(orderId, userMobile)
		} else {
			globals.SugarLogger.Infof("duplicate elm msg received:%v", msg)
		}
	}
	return retVal
}

func (o *OrderController) OrderStatusChanged(msg *elmapi.CallbackMsg, orderId string, innerMsg map[string]interface{}) *elmapi.CallbackResponse {
	db := orm.NewOrm()
	rec := &models.ELMOrder{
		OrderId: orderId,
	}

	err := db.Read(rec, "OrderId")
	if err != nil {
		globals.SugarLogger.Warnf("error when calling ReadOrCreate, error:%v, rec:%v", err, rec)
	} else {
		if rec.Type < msg.Type {
			err = freshfood.FreshFoodAPI.ELMOrderStatus(orderId, msg.Type, utils.GetCurTimeStr())
			if err == nil {
				rec.Type = msg.Type
				err = utils.CallFuncLogError(func() error {
					_, err := db.Update(rec, "Type")
					return err
				}, globals.ErrStrAccessDB)
			}
		} else {
			globals.SugarLogger.Infof("duplicate elm msg received:%v", msg)
		}
	}
	if err != nil {
		return errResponseInternal
	}
	return elmapi.SuccessResponse
}

func (o *OrderController) OrderOtherMsg(msg *elmapi.CallbackMsg, orderId string, innerMsg map[string]interface{}) *elmapi.CallbackResponse {
	var err error
	if msg.Type == elmapi.MsgTypeUserUrgeOrder {
		err = freshfood.FreshFoodAPI.ELMClientUrgeOrder(orderId)
	}

	if err != nil {
		return errResponseInternal
	}
	return elmapi.SuccessResponse
}