package tiktok_store

import (
	"errors"
	"fmt"
	address_create_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/address_create/request"
	address_list_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/address_list/request"
	address_list_response "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/address_list/response"
	freightTemplate_create_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/freightTemplate_create/request"
	freightTemplate_update_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/freightTemplate_update/request"
	shop_batchCreateStore_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_batchCreateStore/request"
	shop_bindStoreFreight_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_bindStoreFreight/request"
	shop_bindStoreSaleLimit_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_bindStoreSaleLimit/request"
	shop_editStore_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_editStore/request"
	shop_getStoreDetail_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_getStoreDetail/request"
	shop_storeSuspend_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_storeSuspend/request"
	shop_unsuspendStore_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_unsuspendStore/request"
	trade_createTradeLimitTemplate_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/trade_createTradeLimitTemplate/request"
	"git.rosy.net.cn/baseapi/platformapi/tiktok_shop/tiktok_api"
	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/baseapi/utils/errlist"
	"git.rosy.net.cn/jx-callback/business/jxcallback/scheduler"
	//"git.rosy.net.cn/jx-callback/business/jxstore/cms"
	"git.rosy.net.cn/jx-callback/business/jxstore/event"
	"git.rosy.net.cn/jx-callback/business/jxutils"
	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
	"git.rosy.net.cn/jx-callback/business/jxutils/tasksch"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/model/dao"
	"git.rosy.net.cn/jx-callback/business/partner"
	"git.rosy.net.cn/jx-callback/globals"
	"git.rosy.net.cn/jx-callback/globals/api"
)

func SplicingTimeToDoudian(openTime1, closeTime1, openTime2, closeTime2 int16) (timeList string) {
	//700 1200 -> 07:00-12:00
	var (
		s1      = ""
		ts1     = ""
		s2      = ""
		ts2     = ""
		s3      = ""
		ts3     = ""
		s4      = ""
		ts4     = ""
		timeStr = ""
	)
	if openTime1 != 0 && closeTime1 != 0 {
		tOpenTime1 := utils.Int64ToStr(int64(openTime1))
		len1 := len(tOpenTime1) - 2
		if utils.Str2Int(tOpenTime1[:len1]) <= 9 {
			ts1 = "0"
		}
		s1 = ts1 + tOpenTime1[:len1] + ":" + tOpenTime1[len1:]
		globals.SugarLogger.Debug("tOpenTime1[:len1]==============", tOpenTime1[:len1])
		globals.SugarLogger.Debug("tOpenTime1[len1+1:]==============", tOpenTime1[len1:])
		globals.SugarLogger.Debug("s1==============", s1)
		globals.SugarLogger.Debug("ts1+tOpenTime1[:len1]+\":\"+tOpenTime1[len1+1:]====", ts1+tOpenTime1[:len1]+":"+tOpenTime1[len1+1:])

		tCloseTime1 := utils.Int64ToStr(int64(closeTime1))
		len2 := len(tCloseTime1) - 2
		if utils.Str2Int(tCloseTime1[:len2]) <= 9 {
			ts2 = "0"
		}
		s2 = ts2 + tCloseTime1[:len2] + ":" + tCloseTime1[len2+1:] + "0"
		timeStr += s1 + "-" + s2
		if openTime2 != 0 && closeTime2 != 0 {
			tOpenTime2 := utils.Int64ToStr(int64(openTime2))
			len3 := len(tOpenTime2) - 2
			if utils.Str2Int(tOpenTime2[:len3]) <= 9 {
				ts3 = "0"
			}
			s3 = ts3 + tOpenTime2[:len3] + ":" + tOpenTime2[len3+1:] + "0"
			tCloseTime2 := utils.Int64ToStr(int64(closeTime2))
			len4 := len(tCloseTime2) - 2
			if utils.Str2Int(tCloseTime2[:len4]) <= 9 {
				ts4 = "0"
			}
			s4 = ts4 + tCloseTime2[:len4] + ":" + tCloseTime2[len4+1:] + "0"
			timeStr += " " + s3 + "-" + s4
		}
	}
	return timeStr
}

// shop/batchCreateStore 批量创建门店
func (P *PurchaseHandler) CreateStore2(db *dao.DaoDB, storeID int, userName string, params map[string]interface{}, storeDetail *dao.StoreDetail) (vendorStoreID string, err error) {
	var (
		storeIDs                  string
		tempStoreID               []int64
		lists                     []shop_batchCreateStore_request.StoreListItem
		ShopBatchCreateStoreParam *shop_batchCreateStore_request.ShopBatchCreateStoreParam
		FreightTemplate           = &model.FreightTemplate{}
	)
	errList := errlist.New()
	a := getAPI(storeDetail.VendorOrgCode, storeID, storeDetail.VendorStoreID)
	timeStr := ""
	if storeDetail.OpenTime1 == 0 || storeDetail.CloseTime1 == 0 {
		return "", fmt.Errorf("营业时间必填")
	} else {
		timeStr = SplicingTimeToDoudian(storeDetail.OpenTime1, storeDetail.CloseTime1, storeDetail.OpenTime2, storeDetail.CloseTime2)
		globals.SugarLogger.Debug("storeDetail.OpenTime1, storeDetail.CloseTime1, storeDetail.OpenTime2, storeDetail.CloseTime2，timeStr===========", storeDetail.OpenTime1, storeDetail.CloseTime1, storeDetail.OpenTime2, storeDetail.CloseTime2, timeStr)
	}
	m := make(map[int64]string)
	for j := 1; j <= 7; j++ {
		m[int64(j)] = timeStr
	}
	list := shop_batchCreateStore_request.StoreListItem{
		RowId:     1,
		Name:      storeDetail.Name,
		StoreCode: utils.Int2Str(storeDetail.Store.ID),
		Longitude: utils.Float64ToStr(jxutils.IntCoordinate2Standard(storeDetail.Lng)),
		Latitude:  utils.Float64ToStr(jxutils.IntCoordinate2Standard(storeDetail.Lat)),
		Province:  storeDetail.ProvinceName,
		City:      storeDetail.CityName,
		District:  storeDetail.DistrictName,
		Address:   storeDetail.Address,
		Contact:   storeDetail.Tel1,
		OpenTime: &shop_batchCreateStore_request.OpenTime{
			DayMap: m,
		},
	}
	lists = append(lists, list)
	ShopBatchCreateStoreParam = &shop_batchCreateStore_request.ShopBatchCreateStoreParam{
		StoreList: lists,
	}
	if resp, err := a.BatchCreateStore(ShopBatchCreateStoreParam); err != nil {
		return "", err
	} else {
		//if len(resp.ResultList) == 0 {
		//	return "", errors.New(fmt.Sprintf("创建店铺失败：%v", err))
		//}
		//for k, v := range resp.ResultList {
		//	if k != len(resp.ResultList) {
		//		storeIDs = utils.Int64ToStr(v.Store.StoreId) + ","
		//	}
		//	storeIDs = utils.Int64ToStr(v.Store.StoreId)
		//}
		storeIDs = utils.Int64ToStr(resp.ResultList[0].Store.StoreId)
		if utils.Str2Int(storeIDs) == 0 || len(resp.ResultList) == 0 {
			return "", errors.New(fmt.Sprintf("创建店铺失败,storeIDs = 0:%v,%v", err, resp.ResultList[0].Msg))
		}
		//创建并绑定运费模板
		if freightTemplateID, err := CreateFreightTemplate(storeDetail.Store.ID); err != nil {
			errList.AddErr(fmt.Errorf("创建运费模板失败：%v", err))
		} else {
			if freightTemplateID == 0 {
				errList.AddErr(fmt.Errorf("创建运费模板失败：%v", err))
			}
			if err = ShopBindStoreFreight(storeDetail.VendorOrgCode, int64(storeDetail.Store.ID), freightTemplateID); err != nil {
				errList.AddErr(fmt.Errorf("本地门店：%d 绑定运费模板:%d失败：%v", int64(storeDetail.Store.ID), freightTemplateID, err))
			} else {
				FreightTemplate.TemplateID = freightTemplateID
				if err = dao.CreateEntity(db, FreightTemplate); err != nil {
					errList.AddErr(fmt.Errorf("运费模板ID存入数据库失败：%v", err))
				}
			}
		}
		//创建并绑定仓库
		if warehouse, err := CreateWarehouse(storeDetail.VendorOrgCode, utils.Int2Str(storeDetail.Store.ID)); err != nil {
			errList.AddErr(fmt.Errorf("创建仓库失败：%v", err))
		} else {
			tempStoreID = append(tempStoreID, int64(storeDetail.Store.ID))
			if err = BindStoreWarehouse(storeDetail.VendorOrgCode, utils.Int64ToStr(warehouse), tempStoreID); err != nil {
				errList.AddErr(fmt.Errorf("门店：%d 绑定仓库:%d 失败：%v", int64(storeDetail.Store.ID), warehouse, err))
			} else {
				FreightTemplate.WarehouseID = warehouse
				if err = dao.CreateEntity(db, FreightTemplate); err != nil {
					errList.AddErr(fmt.Errorf("仓库ID存入数据库失败：%v", err))
				}
			}
		}
		//创建并绑定电子围栏
		if fenceID, err := CreateFenceByStore(storeDetail.VendorOrgCode, int(resp.ResultList[0].Store.StoreId)); err != nil {
			errList.AddErr(fmt.Errorf("创建电子围栏失败：%v", err))
		} else {
			fences := []string{utils.Int2Str(storeDetail.Store.ID)}
			if err := BindFenceByStore(storeDetail.VendorOrgCode, resp.ResultList[0].Store.StoreId, fences); err != nil {
				errList.AddErr(fmt.Errorf("门店：%d 绑定电子围栏:%s 失败：%v", resp.ResultList[0].Store.StoreId, fenceID, err))
			} else {
				FreightTemplate.FenceID = fenceID
				if err := dao.CreateEntity(db, FreightTemplate); err != nil {
					errList.AddErr(fmt.Errorf("电子围栏ID存入数据库失败：%v", err))
				}
			}
		}
		//创建限售模板
		if tradeLimitID, err := CreateTradeLimitTemplate(storeDetail.VendorOrgCode, int64(storeDetail.Store.ID)); err != nil {
			errList.AddErr(fmt.Errorf("创建限售模板失败：%v", err))
		} else {
			if err := BindStoreSaleLimit(storeDetail.VendorOrgCode, resp.ResultList[0].Store.StoreId, tradeLimitID); err != nil {
				errList.AddErr(fmt.Errorf("绑定限售模板失败：%v", err))
			} else {
				FreightTemplate.TradeLimitID = tradeLimitID
				if err := dao.CreateEntity(db, FreightTemplate); err != nil {
					errList.AddErr(fmt.Errorf("限售模板ID存入数据库失败：%v", err))
				}
			}
		}
		FreightTemplate.StoreID = storeDetail.Store.ID
		FreightTemplate.VendorStoreID = storeIDs
		FreightTemplate.DeletedAt = utils.DefaultTimeValue
		if err = dao.CreateEntity(db, FreightTemplate); err != nil {
			errList.AddErr(fmt.Errorf("db update storeID,vendorStoreID defeat on :%v", err))
		}
		return storeIDs, errors.New(fmt.Sprintf("%s", utils.Format4Output(errList, true)))
	}
}

//  shop/editStore 编辑门店信息 正向推送平台
func (P *PurchaseHandler) UpdateStore(db *dao.DaoDB, storeID int, userName string) (err error) {
	var (
		storeInfo *dao.StoreDetail
		name      string
	)
	if db == nil {
		db = dao.GetDB()
	}
	storeInfo, err = dao.GetStoreDetail(db, storeID, model.VendorIDDD, "")
	errList := errlist.New()
	timeStr := ""
	m := make(map[int64]string)
	if storeInfo.OpenTime1 != 0 && storeInfo.CloseTime1 != 0 {
		timeStr = SplicingTimeToDoudian(storeInfo.OpenTime1, storeInfo.CloseTime1, storeInfo.OpenTime2, storeInfo.CloseTime2)
		for j := 1; j <= 7; j++ {
			m[int64(j)] = timeStr
		}
	}
	vendorStoreID := &shop_getStoreDetail_request.ShopGetStoreDetailParam{
		StoreId: utils.Str2Int64(storeInfo.VendorStoreID),
	}
	api := getAPI(storeInfo.VendorOrgCode, storeID, utils.Int64ToStr(vendorStoreID.StoreId))
	if globals.EnableDdStoreWrite {
		remoteStoreInfo, err2 := api.GetStoreDetail(vendorStoreID)
		if err2 != nil {
			return err2
		}
		if remoteStoreInfo.StoreDetail.Store.StoreId == 0 {
			return fmt.Errorf("ID:%d 的门店不存在,请先创建", utils.Str2Int64(storeInfo.VendorStoreID))
		}
		mergedStoreStatus := jxutils.MergeStoreStatus(storeInfo.Status, storeInfo.VendorStatus)
		name = remoteStoreInfo.StoreDetail.Store.Name
		if storeInfo.SyncStatus&(model.SyncFlagNewMask|model.SyncFlagStoreName) != 0 {
			if storeInfo.VendorStoreName != "" {
				name = storeInfo.VendorStoreName
			}
		}
		store := fmt.Sprintf("门店id:%d,门店名称:%s,第三方门店状态:%d,本地修改前门店状态%d,本地门店修改后状态:%d,第三方平台Id(抖店):%s", storeID, remoteStoreInfo.StoreDetail.Store.Name, remoteStoreInfo.StoreDetail.Store.State, storeInfo.Status, mergedStoreStatus, storeInfo.VendorOrgCode)
		event.AddOperateEvent(jxcontext.AdminCtx, jxcontext.AdminCtx.GetTrackInfo(), store, "", "", 10, "UpdateStore")
		params := &shop_editStore_request.ShopEditStoreParam{
			StoreId:   remoteStoreInfo.StoreDetail.Store.StoreId, //平台id不可修改
			Name:      name,
			StoreCode: utils.Int2Str(storeInfo.ID), //自用编码即很本地storeID
			Latitude:  utils.Int2Str(storeInfo.Lat),
			Longitude: utils.Int2Str(storeInfo.Lng),
			Province:  storeInfo.ProvinceName,
			City:      storeInfo.CityName,
			District:  storeInfo.DistrictName,
			Address:   storeInfo.Address,
			Contact:   storeInfo.Tel1,
			OpenTime: &shop_editStore_request.OpenTime{
				DayMap: m,
			},
		}
		//修改店铺状态
		if storeInfo.SyncStatus&(model.SyncFlagNewMask|model.SyncFlagStoreStatus) != 0 {
			errList.AddErr(P.UpdateStoreStatus(jxcontext.AdminCtx, storeInfo.VendorOrgCode, storeID, storeInfo.VendorStoreID, mergedStoreStatus))
		}
		err3 := api.EditStore(params)
		if err3 != nil {
			errList.AddErr(err3)
		} else {
			//更新运费模板
			err = UpdateFreightTemplate(storeID)
			if err != nil {
				return errors.New(fmt.Sprintf("更新运费模板失败，原因:%v", err))
			}
			//更新电子围栏
			err = UpdateFenceByStore(storeInfo.VendorOrgCode, storeID)
			if err != nil {
				return errors.New(fmt.Sprintf("更新电子围栏失败，原因:%v", err))
			}
		}
	}
	return err
}

// UpdateStoreStatus shop/unsuspendStore 门店恢复营业
func (p *PurchaseHandler) UpdateStoreStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, status int) (err error) {
	isOnline := bizStatusJX2DouDian(status)
	api := getAPI(vendorOrgCode, storeID, vendorStoreID)
	if globals.EnableDdStoreWrite {
		if isOnline != tiktok_api.StoreStatusOnline { //暂停营业状态
			unsuspendStoreID := &shop_unsuspendStore_request.ShopUnsuspendStoreParam{
				StoreId: utils.Str2Int64(vendorStoreID),
			}
			if _, err = api.UnsuspendStore(unsuspendStoreID); err != nil {
				return err
			}
		} else { //恢复营业
			suspendStoreID := &shop_storeSuspend_request.ShopStoreSuspendParam{
				StoreId: utils.Str2Int64(vendorStoreID),
			}
			getStoreID := &shop_getStoreDetail_request.ShopGetStoreDetailParam{
				StoreId: utils.Str2Int64(vendorStoreID),
			}
			//平台上店铺状态
			remoteStoreInfo, err2 := api.GetStoreDetail(getStoreID)
			if err2 != nil {
				return err2
			}
			if remoteStoreInfo.StoreDetail.Store.SuspendType == tiktok_api.SuspendTypePlatformPenalty {
				err = errors.New("门店因平台处罚暂停营业，不可主动修改营业状态")
			} else {
				if _, err = api.StoreSuspend(suspendStoreID); err != nil {
					return err
				}
			}
		}
	}
	return err
}

//默认 运费模板只创建 固定运费模板
func CreateFreightTemplate(storeCode int) (int64, error) {
	//获取本地门店信息
	storeDetail, err := dao.GetStoreDetail(dao.GetDB(), storeCode, model.VendorIDDD, "")
	if err != nil {
		return 0, err
	}
	param := &freightTemplate_create_request.FreightTemplateCreateParam{
		Template: &freightTemplate_create_request.Template{
			TemplateName:    "门店编码：" + utils.Int2Str(storeCode) + "的运费模板",
			ProductProvince: int64(storeDetail.ProvinceCode),
			ProductCity:     int64(storeDetail.CityCode),
			CalculateType:   2, //计价方式-1.按重量 2.按数量
			TransferType:    1,
			RuleType:        1,   //卖家包邮
			FixedAmount:     500, //固定运费 单位：分
		},
		Columns: []freightTemplate_create_request.ColumnsItem{
			{
				FirstNum:      1,
				FirstNumPrice: 0.00,
				AddNum:        1,
				AddNumPrice:   0.00,
				RuleAddress:   fmt.Sprintf(`{"%s":{"%s":{"%s":[0]}}}`, utils.Int2Str(storeDetail.ProvinceCode), utils.Int2Str(storeDetail.CityCode)[:2], utils.Int2Str(storeDetail.DistrictCode)[:2]),
				IsOverFree:    true,                                        //是否包邮
				OverAmount:    int64(storeDetail.DeliveryFeeDeductionSill), //此字段在vendor_id=14时 存储满x包邮金额
				ProvinceInfos: []freightTemplate_create_request.ProvinceInfosItem{
					{
						Id: int64(storeDetail.ProvinceCode),
						Children: []freightTemplate_create_request.ChildrenItem_4{
							{
								Id: int64(storeDetail.CityCode),
								Children: []freightTemplate_create_request.ChildrenItem_5{
									{
										Id: int64(storeDetail.DistrictCode),
										Children: []freightTemplate_create_request.ChildrenItem{
											{Id: 0},
										},
									},
								},
							},
						}},
				},
			}},
	}
	resp, err := getAPI(storeDetail.VendorOrgCode, storeCode, storeDetail.VendorStoreID).FreightTemplateCreate(param)
	if err != nil {
		return 0, err
	}
	return resp.TemplateId, nil
}

//  /warehouse/setFence  修改运费模板
func UpdateFreightTemplate(storeCode int) error {
	var (
		columns []freightTemplate_update_request.ColumnsItem
	)
	//获取本地门店信息
	storeDetail, err := dao.GetStoreDetail(dao.GetDB(), storeCode, model.VendorIDDD, "")
	if err != nil {
		return err
	}
	column := freightTemplate_update_request.ColumnsItem{
		FirstNum:      1,
		FirstNumPrice: 0.01,
		AddNum:        1,
		AddNumPrice:   0.01,
		IsOverFree:    true,                                        //是否包邮
		OverAmount:    int64(storeDetail.DeliveryFeeDeductionSill), //此字段在vendor_id=14时 存储 满x包邮金额
	}
	columns = append(columns, column)
	param := &freightTemplate_update_request.FreightTemplateUpdateParam{
		Template: &freightTemplate_update_request.Template{
			TemplateName:    "门店编码：" + utils.Int2Str(storeCode) + "的运费模板",
			ProductProvince: int64(storeDetail.ProvinceCode),
			ProductCity:     int64(storeDetail.CityCode),
			CalculateType:   2, //模板类型为1-固定运费、2-卖家包邮、3-货到付款 时，计价类型传 2-按数量
			TransferType:    1,
			RuleType:        2, //卖家包邮
		},
		Columns: columns,
	}
	_, err = getAPI(storeDetail.VendorOrgCode, storeCode, storeDetail.VendorStoreID).FreightTemplateUpdate(param)
	if err != nil {
		return err
	}
	return nil
}

//  /freightTemplate/create 创建运费模板
func (P *PurchaseHandler) CreateFreightTemplateDirectly(templateInfo freightTemplate_create_request.FreightTemplateCreateParam, storeID, vendorStoreID int64) error {
	var (
		db *dao.DaoDB
	)
	if templateInfo.Template.RuleType > 0 {
		templateInfo.Template.CalculateType = tiktok_api.CalculateTypeNum
	}
	info := &freightTemplate_create_request.FreightTemplateCreateParam{
		Template: templateInfo.Template,
		Columns:  templateInfo.Columns,
	}
	api := getAPI("", int(storeID), utils.Int64ToStr(vendorStoreID))
	resp, err := api.FreightTemplateCreate(info)
	if err != nil {
		return err
	}
	//创建成功后进行绑定
	bindInfo := &shop_bindStoreFreight_request.ShopBindStoreFreightParam{
		StoreId:   vendorStoreID,
		FreightId: resp.TemplateId,
	}
	err = api.BindFreightTemplate(bindInfo)
	if err != nil {
		return err
	}
	//并写入数据库
	freightInfo := model.FreightTemplate{
		StoreID:       int(storeID),
		VendorStoreID: utils.Int64ToStr(vendorStoreID),
		TemplateID:    resp.TemplateId,
	}
	if err = dao.CreateEntity(db, freightInfo); err != nil {
		return err
	}
	return nil
}

// /shop/bindStoreFreight  门店绑定运费模版
//门店绑定运费模版，运费模版必须属于门店关联的抖店，且门店与运费模版是一对一关系
func ShopBindStoreFreight(vendorOrgCode string, storeID, freightID int64) error {
	param := &shop_bindStoreFreight_request.ShopBindStoreFreightParam{
		StoreId:   storeID,
		FreightId: freightID,
	}
	api := getAPI(vendorOrgCode, int(storeID), "")
	err := api.BindFreightTemplate(param)
	if err != nil {
		return err
	}
	return nil
}

//  /address/create 创建店铺地址库（新建即绑定）
func (P *PurchaseHandler) CreateAddress(addressInfo address_create_request.AddressCreateParam) (addressID int64, err error) {
	info := &address_create_request.AddressCreateParam{
		Address: addressInfo.Address,
		StoreId: addressInfo.StoreId,
	}
	api := getAPI("", 0, utils.Int64ToStr(info.StoreId))
	resp, err := api.AddressCreate(info)
	if err != nil {
		return 0, err
	}
	//添加进数据库page_shop
	//获取门店信息
	//storeID := &shop_getStoreDetail_request.ShopGetStoreDetailParam{
	//	StoreId: addressInfo.StoreId,
	//}
	//storeInfo, err1 := api.DouDianApi.GetStoreDetail(storeID)
	//if err1 != nil {
	//	return 0, err1
	//}
	//createAddress := &model.PageShop{ //此表暂存门店售后地址库
	//	Name:          storeInfo.StoreDetail.Store.Name,
	//	VendorID:      model.VendorIDDouDian,
	//	VendorStoreID: utils.Int64ToStr(storeInfo.StoreDetail.Store.StoreId), //抖店平台ID
	//	OrgCode:       storeInfo.StoreDetail.Store.StoreCode,                 //暂时用来存放京西平台门店ID
	//	VendorStatus:  utils.Int64ToStr(storeInfo.StoreDetail.Store.State),
	//	Status:        0,
	//	CityCode:      utils.Str2Int(storeInfo.StoreDetail.Store.CityCode),
	//	DistrictCode:  utils.Str2Int(storeInfo.StoreDetail.Store.DistrictCode),
	//	Address:       storeInfo.StoreDetail.Store.Address,
	//	Lng:           utils.Str2Float64(storeInfo.StoreDetail.Store.Longitude),
	//	Lat:           utils.Str2Float64(storeInfo.StoreDetail.Store.Latitude),
	//	Tel1:          storeInfo.StoreDetail.Store.Contact,
	//}
	//if err = dao.CreateEntity(dao.GetDB(), createAddress); err != nil {
	//	return 0, err
	//}
	return resp.AddressId, nil
}

// /address/list 获取售后地址列表接口
//分页获取商家地址列表
func (P *PurchaseHandler) GetAddressList(param *address_list_request.AddressListParam) (*address_list_response.AddressListData, error) {
	//不传入ID则是获取所有门店售后地址列表
	info := &address_list_request.AddressListParam{
		PageSize:   10,
		PageNo:     1,
		OrderBy:    param.OrderBy,
		OrderField: param.OrderField,
	}
	if param.StoreId != 0 {
		info.StoreId = param.StoreId
	}
	listInfo, err := getAPI("", 0, utils.Int64ToStr(info.StoreId)).GetAddressList(info)
	if err != nil {
		return nil, err
	}
	return listInfo, nil
}

// /trade/createTradeLimitTemplate 创建限售模板
func CreateTradeLimitTemplate(appOrgCode string, storeID int64) (tradeLimitID int64, err error) {
	var (
		items []trade_createTradeLimitTemplate_request.TradeLimitRuleRequestListItem
	)
	item := trade_createTradeLimitTemplate_request.TradeLimitRuleRequestListItem{
		TradeLimitModel:    tiktok_api.TradeLimitModelQuantity,
		TradeLimitResource: tiktok_api.TradeLimitResourceDouDian,
		TradeLimitPattern: &trade_createTradeLimitTemplate_request.TradeLimitPattern{
			Minimum:       1,
			Maximum:       1000,
			CumulativeMax: 10000,
		},
		TradeLimitSubjectList: []int32{tiktok_api.TradeLimitSubjectBuyMobile},
	}
	items = append(items, item)
	param := &trade_createTradeLimitTemplate_request.TradeCreateTradeLimitTemplateParam{
		StoreId:                   storeID,
		TradeLimitRuleRequestList: items,
	}
	resp, err := getAPI(appOrgCode, 0, utils.Int64ToStr(storeID)).CreateTradeLimitTemplate(param)
	if err != nil {
		return 0, err
	}
	return resp.TradeLimitId, nil
}

// /shop/bindStoreSaleLimit 门店绑定限售模板
func BindStoreSaleLimit(appOrgCode string, storeID, saleLimitTemplateID int64) error {
	info := &shop_bindStoreSaleLimit_request.ShopBindStoreSaleLimitParam{
		StoreId:     storeID,
		SaleLimitId: saleLimitTemplateID,
	}
	if err := getAPI(appOrgCode, 0, utils.Int64ToStr(info.StoreId)).BindStoreSaleLimit(info); err != nil {
		return err
	}
	return nil
}

func (P *PurchaseHandler) UpdateStoreOpTime(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, opTimeList []int16) (err error) {
	t1 := opTimeList[0]
	t2 := opTimeList[1]
	t3 := opTimeList[2]
	t4 := opTimeList[4]
	timeStr := SplicingTimeToDoudian(t1, t2, t3, t4)
	m := make(map[int64]string)
	for j := 1; j <= 7; j++ {
		m[int64(j)] = timeStr
	}
	params := &shop_editStore_request.ShopEditStoreParam{
		StoreId: utils.Str2Int64(vendorStoreID),
		OpenTime: &shop_editStore_request.OpenTime{
			DayMap: m,
		},
	}
	if globals.EnableDdStoreWrite {
		err = getAPI(vendorOrgCode, storeID, vendorStoreID).EditStore(params)
	}
	return err
}

//获取门店状态
func (P *PurchaseHandler) GetStoreStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string) (storeStatus int, err error) {
	params := &shop_getStoreDetail_request.ShopGetStoreDetailParam{
		StoreId:            utils.Str2Int64(vendorStoreID),
		IsNeedChargeInfo:   false,
		IsNeedPoiAuditInfo: false,
		IsNeedRelShopUser:  false,
	}
	result, err := getAPI(vendorOrgCode, storeID, vendorStoreID).GetStoreDetail(params)
	if err != nil {
		return 0, err
	}
	poiStatus := int(result.StoreDetail.Store.PoiAuditState)
	//status := bizStatusJX2DouDian(int(result.StoreDetail.Store.PoiAuditState))
	return poiStatus, nil
}

func (P *PurchaseHandler) EnableAutoAcceptOrder(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, isSetEnable bool) (err error) {
	return err
}

// 获取店铺所有平台ID
func (P *PurchaseHandler) GetAllStoresVendorID(ctx *jxcontext.Context, vendorOrgCode string) (vendorStoreIDs []string, err error) {
	//param := &shop_getStoreList_request.ShopGetStoreListParam{
	//	Page:     0,
	//	PageSize: 10,
	//}
	//storeList, err := api.DouDianApi.GetStoreList(param)
	//if err != nil {
	//	return nil, err
	//}
	//if len(storeList.StoreDetailList) > 0 {
	//	vendorStoreIDs = make([]string, len(storeList.StoreDetailList))
	//	for k, v := range storeList.StoreDetailList {
	//		vendorStoreIDs[k] = utils.Int64ToStr(v.Store.StoreId)
	//	}
	//}
	//return vendorStoreIDs, err
	return nil, err
}

func (P *PurchaseHandler) UpdateStoreLineStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, lineStatus int) (err error) {
	api := getAPI(vendorOrgCode, storeID, vendorStoreID)
	if lineStatus == model.StoreStatusOpened {
		param := &shop_unsuspendStore_request.ShopUnsuspendStoreParam{
			StoreId: utils.Str2Int64(vendorStoreID),
		}
		_, err = api.UnsuspendStore(param)
	} else {
		param := &shop_storeSuspend_request.ShopStoreSuspendParam{
			StoreId: utils.Str2Int64(vendorStoreID),
		}
		_, err = api.StoreSuspend(param)
	}
	return err
}
func (P *PurchaseHandler) ReadStore(ctx *jxcontext.Context, vendorOrgCode, vendorStoreID, vendorStoreName string) (store *dao.StoreDetail, err error) {
	vendorStore, err := getAPI(vendorOrgCode, 0, "").GetStoreDetail(&shop_getStoreDetail_request.ShopGetStoreDetailParam{StoreId: utils.Str2Int64(vendorStoreID)})
	if err != nil {
		return nil, err
	}
	retVal := &dao.StoreDetail{
		Store: model.Store{
			Address: vendorStore.StoreDetail.Store.Address,
			Tel1:    vendorStore.StoreDetail.Store.Contact,
		},
	}
	retVal.OriginalName = vendorStore.StoreDetail.Store.Name
	_, retVal.Name = jxutils.SplitStoreName(retVal.OriginalName, partner.StoreNameSeparator, globals.StoreNameTiktok)

	retVal.SetTiktokOpenTime(vendorStore.StoreDetail.Store.OpenTime.DayMap[1])
	retVal.Status = bizStatusTiktok2JX(vendorStore.StoreDetail.Store.State)

	//tel2 := result.StandbyTel
	//if tel2 != "" && tel2 != retVal.Tel1 {
	//	retVal.Tel2 = tel2
	//}

	retVal.Lng = int(utils.Str2Float64(vendorStore.StoreDetail.Store.Longitude) * 1000000)
	retVal.Lat = int(utils.Str2Float64(vendorStore.StoreDetail.Store.Latitude) * 1000000)

	lng := jxutils.IntCoordinate2Standard(retVal.Lng)
	lat := jxutils.IntCoordinate2Standard(retVal.Lat)
	db := dao.GetDB()
	retVal.DistrictCode = api.AutonaviAPI.GetCoordinateDistrictCode(lng, lat)
	city, err := dao.GetPlaceByCode(db, utils.Str2Int(vendorStore.StoreDetail.Store.CityCode))
	retVal.CityName = city.Name
	retVal.CityCode = utils.Str2Int(vendorStore.StoreDetail.Store.CityCode)

	poiCode := vendorStore.StoreDetail.Store.StoreCode
	retVal.VendorStoreID = vendorStoreID
	retVal.ID = utils.Str2Int(poiCode)
	retVal.DeliveryRangeType = model.DeliveryRangeTypeRadius
	retVal.DeliveryRange = "3000"
	retVal.DeliveryType = scheduler.StoreDeliveryTypeByStore
	//retVal.DeliveryRangeType = model.DeliveryRangeTypePolygon
	//var deliveryRangeInfo []map[string]interface{}
	//deliveryRangeInfo, err = getAPIWithoutToken(vendorOrgCode).ShippingFetch(poiCode)
	//if err != nil {
	//	deliveryRangeInfo, err = getAPIWithoutToken(vendorOrgCode).ShippingList(poiCode)
	//}
	//if err == nil {
	//	if len(deliveryRangeInfo) > 0 {
	//		retVal.DeliveryRange = rangeMtwm2JX(deliveryRangeInfo[0]["area"].(string))
	//		logisticsCode := utils.Interface2String(deliveryRangeInfo[0]["logistics_code"])
	//		if logisticsCode == "" || logisticsCode == mtwmapi.PeiSongTypeSelf {
	//			retVal.DeliveryType = scheduler.StoreDeliveryTypeByStore
	//		} else {
	//			retVal.DeliveryType = scheduler.StoreDeliveryTypeByPlatform
	//		}
	//	}
	//}
	return retVal, nil
}

func (P *PurchaseHandler) RefreshAllStoresID(ctx *jxcontext.Context, parentTask tasksch.ITask, isAsync bool) (hint string, err error) {
	return "", errors.New("抖店暂不支持此操作")
}

func bizStatusJX2DouDian(status int) (onLine int) {
	if status == model.StoreStatusDisabled || status == model.StoreStatusClosed || status == model.StoreStatusHaveRest {
		return tiktok_api.StoreStatusOffline
	}
	return tiktok_api.StoreStatusOnline
}

func (P *PurchaseHandler) DeleteStore(db *dao.DaoDB, storeID int, userName string) (err error) {
	return errors.New("抖店暂不支持此操作")
}

func (P *PurchaseHandler) UpdateStoreCustomID(ctx *jxcontext.Context, vendorOrgCode, vendorStoreID string, storeID int64) (err error) {
	return err
}

func (P *PurchaseHandler) GetOrderStatus(vendorOrgCode, vendorOrderID string) (status int, err error) {
	return 0, errors.New("抖店暂不支持此操作")
}

// /address/getProvince 获取四级地址全量省份信息
//func (P *PurchaseHandler) GetProvince()([]) {
//
//}