package ebaiapi

import (
	"fmt"
	"net/http"
	"strings"
	"time"

	"git.rosy.net.cn/baseapi"
	"git.rosy.net.cn/baseapi/platformapi"
	"git.rosy.net.cn/baseapi/utils"
)

const (
	storeURL     = "https://be.ele.me"
	swithShopURL = "crm/manager/switchshop"
)

const (
	ReplyStatusAll        = -1
	ReplyStatusNotReplied = 0
	ReplyStatusReplied    = 1

	CommentLevelAll = -1
	CommentLevel1   = 1
	CommentLevel2   = 2
	CommentLevel3   = 3
	CommentLevel4   = 4
	CommentLevel5   = 5

	CommentContentAll         = -1
	CommentContentHaveContent = 1
	CommentContentNoContent   = 0
)

type PageShopUserInfo struct {
	CategoryID    string      `json:"category_id"`
	CityID        string      `json:"city_id"`
	CityName      string      `json:"city_name"`
	DeliveryParty string      `json:"delivery_party"`
	EleID         string      `json:"ele_id"`
	EleSoaToken   string      `json:"ele_soa_token"`
	IsAPI         int         `json:"is_api"`
	IsStore       interface{} `json:"is_store"`
	MerchantID    string      `json:"merchant_id"`
	MerchantName  string      `json:"merchant_name"`
	Role          struct {
		Ename      string `json:"ename"`
		Name       string `json:"name"`
		ShopRoleID int64  `json:"shop_role_id"`
	} `json:"role"`
	SalesID        string `json:"sales_id"`
	SalesName      string `json:"sales_name"`
	ServicePackage struct {
		BaiduSign int `json:"baiduSign"`
		EleSign   int `json:"eleSign"`
	} `json:"service_package"`
	ShopInfo struct {
		AreaID              string      `json:"area_id"`
		BaiduBusinessState  string      `json:"baidu_business_state"`
		BaiduOnlineStatus   string      `json:"baidu_online_status"`
		BaiduTakeoutLogo    string      `json:"baidu_takeout_logo"`
		CategoryID          string      `json:"category_id"`
		CategoryIds         string      `json:"category_ids"`
		CategoryName        string      `json:"category_name"`
		County              string      `json:"county"`
		CreateType          string      `json:"create_type"`
		CreatedAt           string      `json:"created_at"`
		CrmOncallType       int         `json:"crm_oncall_type"`
		EffectiveAt         string      `json:"effective_at"`
		EleBusinessState    string      `json:"ele_business_state"`
		EleDeliveryParty    string      `json:"ele_delivery_party"`
		EleID               string      `json:"ele_id"`
		EleOnlineStatus     string      `json:"ele_online_status"`
		EleShopLogo         interface{} `json:"ele_shop_logo"`
		IsSignZhongbao      string      `json:"is_sign_zhongbao"`
		OnlineStatus        string      `json:"online_status"`
		Phone               string      `json:"phone"`
		ServStatus          string      `json:"serv_status"`
		ShopTransactionOpen int         `json:"shop_transaction_open"`
		SourceName          string      `json:"source_name"`
		SupplierID          string      `json:"supplier_id"`
		TakeoutBoxPrice     string      `json:"takeout_box_price"`
		TakeoutDispatchTime []struct {
			End   string `json:"end"`
			Start string `json:"start"`
		} `json:"takeout_dispatch_time"`
		TakeoutOncallType string `json:"takeout_oncall_type"`
		TakeoutOpenTime   []struct {
			End   string `json:"end"`
			Start string `json:"start"`
		} `json:"takeout_open_time"`
		TakeoutServicePhone string `json:"takeout_service_phone"`
		TakeoutShopLogo     string `json:"takeout_shop_logo"`
		TransferStatus      string `json:"transfer_status"`
	} `json:"shop_info"`
	ShopRole           int    `json:"shop_role"`
	ShopUserID         string `json:"shop_user_id"`
	SwitchFromSupplier int    `json:"switch_from_supplier"`
	UserName           string `json:"user_name"`
	UserPhone          string `json:"user_phone"`
	YellowPrompt       struct {
		Capacity       int           `json:"capacity"`
		Complete       int           `json:"complete"`
		Display        bool          `json:"display"`
		Msg            string        `json:"msg"`
		MsgCount       int           `json:"msg_count"`
		MsgList        []interface{} `json:"msg_list"`
		Online         int           `json:"online"`
		PcURL          string        `json:"pc_url"`
		TransferStatus string        `json:"transfer_status"`
		Type           int           `json:"type"`
		URL            string        `json:"url"`
	} `json:"yellow_prompt"`
}

type PageShopHealthInfo struct {
	MerchantID   string `json:"merchant_id"`
	MerchantName string `json:"merchant_name"`

	BadOrderRate      string `json:"bad_order_rate"`
	Category2         string `json:"category_2"`
	Data              string `json:"data"`
	EndTime           string `json:"endTime"`
	HasPhotoRate      string `json:"has_photo_rate"`
	Hours             string `json:"hours"`
	ID                string `json:"id"`
	IsButie           string `json:"is_butie"`
	IsCp              string `json:"is_cp"`
	IsDeliverFee      string `json:"is_deliver_fee"`
	IsGood            string `json:"is_good"`
	IsHealthy         string `json:"is_healthy"`
	IsJiedan          string `json:"is_jiedan"`
	IsManjian         string `json:"is_manjian"`
	IsQisong          string `json:"is_qisong"`
	IsShopNew         string `json:"is_shop_new"`
	IsSku             string `json:"is_sku"`
	IsYinye           string `json:"is_yinye"`
	IsYoutu           string `json:"is_youtu"`
	IsZs              string `json:"is_zs"`
	MinDeliveryFee    string `json:"min_delivery_fee"`
	MinDeliveryPrice  string `json:"min_delivery_price"`
	RestaurantSubsidy string `json:"restaurant_subsidy"`
	ShopCategory      string `json:"shop_category"`
	ShopID            string `json:"shop_id"`
	SkuNum            string `json:"sku_num"`
	StartTime         string `json:"startTime"`
	TargetButie       string `json:"target_butie"`
	TargetCp          string `json:"target_cp"`
	TargetDeliverFee  string `json:"target_deliver_fee"`
	TargetJiedan      string `json:"target_jiedan"`
	TargetQisong      string `json:"target_qisong"`
	TargetSku         string `json:"target_sku"`
	TargetYinye       string `json:"target_yinye"`
	TargetYoutu       string `json:"target_youtu"`
	UnvalidOrderNum   string `json:"unvalid_order_num"`
	UpdateTime        string `json:"update_time"`
	Week              string `json:"week"`
}

func (a *API) SetStoreCookie(key, value string) {
	a.locker.Lock()
	defer a.locker.Unlock()
	a.storeCookies[key] = value
}

func (a *API) GetStoreCookie(key string) string {
	a.locker.RLock()
	defer a.locker.RUnlock()
	return a.storeCookies[key]
}

func (a *API) AccessStorePage2(subURL string, params map[string]interface{}, cookies map[string]string) (retVal map[string]interface{}, err error) {
	a.locker.RLock()
	storeCookieLen := len(a.storeCookies)
	a.locker.RUnlock()
	if storeCookieLen == 0 {
		return nil, fmt.Errorf("需要设置Store Cookie才能使用此方法")
	}
	err = platformapi.AccessPlatformAPIWithRetry(a.client,
		func() *http.Request {
			var request *http.Request
			fullURL := utils.GenerateGetURL(storeURL, subURL, nil)
			if params == nil {
				// baseapi.SugarLogger.Debug(fullURL)
				request, _ = http.NewRequest(http.MethodGet, fullURL, nil)
			} else {
				request, _ = http.NewRequest(http.MethodPost, fullURL, strings.NewReader(utils.Map2URLValues(params).Encode()))
				request.Header.Set("charset", "UTF-8")
				request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
			}
			a.locker.RLock()
			for k, v := range a.storeCookies {
				request.AddCookie(&http.Cookie{
					Name:  k,
					Value: v,
				})
			}
			for k, v := range cookies {
				request.AddCookie(&http.Cookie{
					Name:  k,
					Value: v,
				})
			}
			a.locker.RUnlock()
			return request
		},
		a.config,
		func(response *http.Response, jsonResult1 map[string]interface{}) (errLevel string, err error) {
			retVal = jsonResult1
			code := int(utils.MustInterface2Int64(jsonResult1["errno"]))
			if code == ResponseCodeSuccess {
				if subURL == swithShopURL {
					for _, v := range response.Cookies() {
						if v.Name == "SWITCH_SHOP" {
							retVal = utils.Struct2FlatMap(v)
							break
						}
					}
				} else {
					retVal, _ = jsonResult1["data"].(map[string]interface{})
				}
				return platformapi.ErrLevelSuccess, nil
			}
			newErr := utils.NewErrorIntCode(jsonResult1["errmsg"].(string), code)
			if code == ResponseCodeCallElmFailed {
				return platformapi.ErrLevelRecoverableErr, newErr
			}
			baseapi.SugarLogger.Debugf("ebai AccessStorePage failed, jsonResult1:%s", utils.Format4Output(jsonResult1, true))
			return platformapi.ErrLevelCodeIsNotOK, newErr
		})
	return retVal, err
}

func (a *API) AccessStorePage(subURL string, params map[string]interface{}) (retVal map[string]interface{}, err error) {
	return a.AccessStorePage2(subURL, params, nil)
}

func (a *API) GetRealMobile4Order(orderId string) (mobile string, err error) {
	retVal, err := a.GetStoreOrderInfo(orderId)
	if err == nil {
		return retVal["order_basic"].(map[string]interface{})["user_phone_call"].(string), nil
	}
	return "", err
}

func (a *API) GetStoreOrderInfo(orderId string) (storeOrderInfo map[string]interface{}, err error) {
	retVal, err := a.AccessStorePage(fmt.Sprintf("crm/orderlist?keyword=%s", orderId), nil)
	// baseapi.SugarLogger.Debug(utils.Format4Output(retVal, false))
	if err == nil {
		resultList := retVal["order_list"].([]interface{})
		if len(resultList) > 0 {
			return resultList[0].(map[string]interface{}), nil
		}
		return nil, fmt.Errorf("不能找到订单：%s的相关信息", orderId)
	}
	return nil, err
}

func (a *API) GetStoreOrderInfoList(fromTime, toTime string, shopID string, orderStatus int) (storeOrderList []map[string]interface{}, err error) {
	// pageSize := 20
	pageNo := 1
	urlTemplate := "crm/orderlist?start_timestamp=%d&end_timestamp=%d&shop_id=%s"
	params := []interface{}{
		utils.Str2Time(fromTime).Unix(),
		utils.Str2Time(toTime).Unix(),
		shopID,
	}
	if orderStatus >= 0 {
		urlTemplate += "&order_status=%d"
		params = append(params, orderStatus)
	}
	fixedURL := fmt.Sprintf(urlTemplate, params...)
	for {
		retVal, err2 := a.AccessStorePage(fixedURL+"&page="+utils.Int2Str(pageNo), nil)
		// baseapi.SugarLogger.Debug(utils.Format4Output(retVal, false))
		if err = err2; err == nil {
			resultList := retVal["order_list"].([]interface{})
			storeOrderList = append(storeOrderList, utils.Slice2MapSlice(resultList)...)
			if len(storeOrderList) >= int(utils.MustInterface2Int64(retVal["order_count"])) {
				return storeOrderList, nil
			}
			pageNo++
		} else {
			return nil, err
		}
	}
	return nil, err
}

func (a *API) getCommentList(isElm bool, fromTime, toTime time.Time, shopID, supplierID string, replyStatus, level, nonEmpty int) (commentList []map[string]interface{}, err error) {
	pageSize := 200
	pageNo := 1
	urlTemplate := "crm/%s?start_time=%s&end_time=%s&page_count=%d"
	params := []interface{}{
		[]string{
			"getelecommentlist",
			"getcommentlist",
		}[1-utils.Bool2Int(isElm)],
		utils.Time2Str(fromTime),
		utils.Time2Str(toTime),
		pageSize,
	}
	if shopID != "" {
		urlTemplate += "&shop_id=%s"
		params = append(params, shopID)
	} else if supplierID != "" {
		urlTemplate += "&supplier_id=%s"
		params = append(params, supplierID)
	}
	if replyStatus != ReplyStatusAll {
		urlTemplate += "&reply_status=%d"
		params = append(params, replyStatus)
	}
	if level != CommentLevelAll {
		urlTemplate += "&level=%d"
		params = append(params, level)
	}
	if nonEmpty != CommentContentAll {
		urlTemplate += "&nonempty=%d"
		params = append(params, replyStatus)
	}
	fixedURL := fmt.Sprintf(urlTemplate, params...)
	for {
		retVal, err2 := a.AccessStorePage(fixedURL+"&page_num="+utils.Int2Str(pageNo), nil)
		if err = err2; err == nil {
			for _, comment := range retVal["comment_list"].([]interface{}) {
				commentMap := comment.(map[string]interface{})
				for _, orderComment := range commentMap["order_commentList"].([]interface{}) {
					orderCommentMap := orderComment.(map[string]interface{})
					orderCommentMap["order_id"] = commentMap["order_id"]
					orderCommentMap["shop_id"] = commentMap["shop_id"]
					commentList = append(commentList, orderComment.(map[string]interface{}))
				}
			}
			if len(commentList) >= int(utils.MustInterface2Int64(retVal["total"])) {
				return commentList, nil
			}
			pageNo++
		} else {
			return nil, err
		}
	}
	return nil, err
}

func (a *API) GetEleCommentList(fromTime, toTime time.Time, shopID, supplierID string, replyStatus, level, nonEmpty int) (commentList []map[string]interface{}, err error) {
	return a.getCommentList(true, fromTime, toTime, shopID, supplierID, replyStatus, level, nonEmpty)
}

func (a *API) GetCommentList(fromTime, toTime time.Time, shopID, supplierID string, replyStatus, level, nonEmpty int) (commentList []map[string]interface{}, err error) {
	return a.getCommentList(false, fromTime, toTime, shopID, supplierID, replyStatus, level, nonEmpty)
}

func (a *API) PageGetSkuList(baiduShopID int64) (skuList []map[string]interface{}, err error) {
	pageSize := 200
	pageNo := 1
	urlTemplate := "commodity/getskulist?wid=%d&perpage=%d&upc_type=2&weight=2"
	params := []interface{}{
		baiduShopID,
		pageSize,
	}
	fixedURL := fmt.Sprintf(urlTemplate, params...)
	for {
		retVal, err2 := a.AccessStorePage(fixedURL+"&curpage="+utils.Int2Str(pageNo), nil)
		if err = err2; err == nil {
			for _, sku := range retVal["sku_list"].([]interface{}) {
				skuList = append(skuList, sku.(map[string]interface{}))
			}
			if len(skuList) >= int(utils.Str2Int64(utils.Interface2String(retVal["total"]))) {
				return skuList, nil
			}
			pageNo++
		} else {
			return nil, err
		}
	}
	return nil, err
}

func (a *API) PageGetCustomSkuList(baiduShopID int64, customCatID int64) (skuList []map[string]interface{}, err error) {
	urlTemplate := "commodity/getCustomSkuList?wid=%d&custom_cat_id=%d"
	params := []interface{}{
		baiduShopID,
		customCatID,
	}
	fixedURL := fmt.Sprintf(urlTemplate, params...)
	retVal, err := a.AccessStorePage(fixedURL, nil)
	if err == nil {
		return utils.Slice2MapSlice(retVal["sku_list"].([]interface{})), nil
	}
	return nil, err
}

func (a *API) PageGetCustomCatList(baiduShopID int64) (catList []map[string]interface{}, err error) {
	urlTemplate := "commodity/GetCustomCatList?wid=%d"
	params := []interface{}{
		baiduShopID,
	}
	fixedURL := fmt.Sprintf(urlTemplate, params...)
	retVal, err := a.AccessStorePage(fixedURL, nil)
	if err == nil {
		return utils.Slice2MapSlice(retVal["cat_list"].([]interface{})), nil
	}
	return nil, err
}

func (a *API) SwitchShop(baiduShopID int64) (switchShopCookie string, err error) {
	result, err := a.AccessStorePage("crm/manager/switchshop", map[string]interface{}{
		"switch_shop_id": baiduShopID,
	})
	if err == nil {
		switchShopCookie = utils.Interface2String(result["Value"])
	}
	return switchShopCookie, err
}

func (a *API) GetShopUserInfo2(switchShopCookie string) (shopUserInfo *PageShopUserInfo, err error) {
	shopInfo, err := a.AccessStorePage2("crm/account/getshopuserinfo", nil, map[string]string{
		"SWITCH_SHOP": switchShopCookie,
	})
	if err == nil {
		err = utils.Map2StructByJson(shopInfo, &shopUserInfo, true)
	}
	return shopUserInfo, err
}

func (a *API) GetShopUserInfo(baiduShopID int64) (shopUserInfo *PageShopUserInfo, err error) {
	switchShopCookie, err := a.SwitchShop(baiduShopID)
	if err != nil {
		return nil, err
	}
	return a.GetShopUserInfo2(switchShopCookie)
}

func (a *API) GetShopHealthByDetail2(switchShopCookie string) (shopHealthDetail *PageShopHealthInfo, err error) {
	shopInfo, err := a.GetShopUserInfo2(switchShopCookie)
	if err != nil {
		return nil, err
	}
	result, err := a.AccessStorePage2("crm/getshophealthydetail", map[string]interface{}{
		"shop_id": shopInfo.EleID,
	}, map[string]string{
		"SWITCH_SHOP": switchShopCookie,
	})
	if err == nil {
		if err = utils.Map2StructByJson(result, &shopHealthDetail, true); err == nil {
			shopHealthDetail.MerchantID = shopInfo.MerchantID
			shopHealthDetail.MerchantName = shopInfo.MerchantName
		}
	}
	return shopHealthDetail, err
}

func (a *API) GetShopHealthByDetail(baiduShopID int64) (shopHealthDetail *PageShopHealthInfo, err error) {
	switchShopCookie, err := a.SwitchShop(baiduShopID)
	if err != nil {
		return nil, err
	}
	return a.GetShopHealthByDetail2(switchShopCookie)
}