package jd

import (
	"strings"

	"git.rosy.net.cn/jx-callback/business/jxcallback/scheduler"
	"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/dao"
	"git.rosy.net.cn/jx-callback/business/partner"
	"git.rosy.net.cn/jx-callback/globals"

	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/globals/api"
)

const (
	VendorStorePrefix = "京西菜市"
)

type tJdStoreInfo struct {
	model.Store
	JdCityCode       int
	JdDistrictCode   int
	JdStoreStatus    int
	VendorStoreID    string `orm:"column(vendor_store_id)"`
	RealLastOperator string
	SyncStatus       int
}

func (p *PurchaseHandler) ReadStore(vendorStoreID string) (*model.Store, error) {
	result, err := api.JdAPI.GetStoreInfoByStationNo(vendorStoreID)
	if err == nil {
		retVal := &model.Store{
			Address:    utils.Interface2String(result["stationAddress"]),
			OpenTime1:  JdOperationTime2JxOperationTime(result["serviceTimeStart1"]),
			CloseTime1: JdOperationTime2JxOperationTime(result["serviceTimeEnd1"]),
			OpenTime2:  JdOperationTime2JxOperationTime(result["serviceTimeStart2"]),
			CloseTime2: JdOperationTime2JxOperationTime(result["serviceTimeEnd2"]),
			Status:     JdStoreStatus2JxStatus(result["yn"], result["closeStatus"]),
			Tel1:       utils.Interface2String(result["phone"]),
		}
		_, retVal.Name = jxutils.SplitStoreName(utils.Interface2String(result["stationName"]), partner.StoreNameSeparator, VendorStorePrefix)
		retVal.DeliveryType = JdDeliveryType2Jx(int(utils.MustInterface2Int64(result["carrierNo"])))

		tel2 := utils.Interface2String(result["mobile"])
		if tel2 != "" && tel2 != retVal.Tel1 {
			retVal.Tel2 = tel2
		}
		lng := utils.MustInterface2Float64(result["lng"])
		lat := utils.MustInterface2Float64(result["lat"])
		retVal.Lng = jxutils.StandardCoordinate2Int(lng)
		retVal.Lat = jxutils.StandardCoordinate2Int(lat)

		cityCode := int(utils.MustInterface2Int64(result["city"]))
		if cityCode != 0 {
			db := dao.GetDB()
			if city, err2 := dao.GetPlaceByJdCode(db, cityCode); err2 == nil {
				retVal.CityCode = city.Code
				districtName := utils.Interface2String(result["countyName"]) // 京东的市区号码与通用数据完全无法关联，只有通过名字来关联
				if retVal.CityCode != 0 && districtName != "" {
					if district, err2 := dao.GetPlaceByName(db, districtName, 3, city.Code); err2 == nil {
						retVal.DistrictCode = district.Code
					}
				}
				if retVal.DistrictCode == 0 {
					retVal.DistrictCode = api.AutonaviAPI.GetCoordinateDistrictCode(lng, lat)
					if district, err := dao.GetPlaceByCode(db, retVal.DistrictCode); err == nil {
						retVal.CityCode = district.ParentCode
					}
				}
			}
		}

		retVal.ID = int(utils.Str2Int64WithDefault(utils.Interface2String(result["outSystemId"]), 0))
		result, err2 := api.JdAPI.GetDeliveryRangeByStationNo(vendorStoreID)
		if err = err2; err == nil {
			retVal.DeliveryRangeType = int8(utils.MustInterface2Int64(result["deliveryRangeType"]))
			if retVal.DeliveryRangeType == model.DeliveryRangeTypePolygon {
				retVal.DeliveryRange = strings.Trim(utils.Interface2String(result["deliveryRange"]), ";")
			} else {
				retVal.DeliveryRange = utils.Int64ToStr(utils.MustInterface2Int64(result["deliveryRangeRadius"]))
			}
			return retVal, nil
		}
	}
	return nil, err
}

// stoerIDs为nil表示所有
func (p *PurchaseHandler) UpdateStore(db *dao.DaoDB, storeID int, userName string) (err error) {
	var stores []*tJdStoreInfo
	sql := `
	SELECT t1.*, city.jd_code jd_city_code, district.jd_code jd_district_code, t2.status jd_store_status, t2.vendor_store_id,
	IF(t1.updated_at > t2.updated_at, t1.last_operator, t2.last_operator) real_last_operator, t2.sync_status
	FROM store t1
	JOIN store_map t2 ON t1.id = t2.store_id AND t2.vendor_id = ? AND (t2.deleted_at = ? OR t2.sync_status <> 0)
	LEFT JOIN place city ON t1.city_code = city.code
	LEFT JOIN place district ON t1.district_code = district.code
	WHERE t1.id = ?
	ORDER BY t2.updated_at
	`
	if err = dao.GetRows(db, &stores, sql, model.VendorIDJD, utils.DefaultTimeValue, storeID); err == nil {
		for _, store := range stores {
			outSystemID := ""
			if store.SyncStatus&model.SyncFlagDeletedMask == 0 {
				outSystemID = utils.Int2Str(int(store.ID))
			}
			params := map[string]interface{}{
				"outSystemId":       outSystemID, // todo 直接修改这个字段可能会有问题
				"stationName":       jxutils.ComposeStoreName(store.Name, partner.StoreNameSeparator, VendorStorePrefix),
				"stationAddress":    store.Address,
				"serviceTimeStart1": JxOperationTime2JdOperationTime(store.OpenTime1),
				"serviceTimeEnd1":   JxOperationTime2JdOperationTime(store.CloseTime1),
				"deliveryRangeType": store.DeliveryRangeType,
				"coordinateType":    3, // 一直用高德
				"lng":               jxutils.IntCoordinate2Standard(store.Lng),
				"lat":               jxutils.IntCoordinate2Standard(store.Lat),
				"city":              store.JdCityCode,
				"county":            store.JdDistrictCode,
				"phone":             store.Tel1,
				"mobile":            store.Tel2,
			}
			if store.DeliveryRangeType == model.DeliveryRangeTypePolygon {
				params["coordinatePoints"] = store.DeliveryRange
			} else {
				params["deliveryRangeRadius"] = utils.Str2Int64(store.DeliveryRange)
			}

			openTime2 := JxOperationTime2JdOperationTime(store.OpenTime2)
			if openTime2 != 0 {
				params["serviceTimeStart2"] = openTime2
				params["serviceTimeEnd2"] = JxOperationTime2JdOperationTime(store.CloseTime2)
			}
			_, params["closeStatus"] = JxStoreStatus2JdStatus(jxutils.MergeStoreStatus(store.Status, store.JdStoreStatus))
			// globals.SugarLogger.Debug(utils.Format4Output(params, false))
			if globals.EnableStoreWrite {
				if err = api.JdAPI.UpdateStoreInfo4Open(store.VendorStoreID, store.RealLastOperator, params); err != nil {
					return err
				}
			}
		}
	}
	return err
}

// 没用
// func (p *PurchaseHandler) DeleteStore(vendorStoreID, userName string) error {
// 	params := map[string]interface{}{
// 		"yn": 1,
// 	}
// 	return api.JdAPI.UpdateStoreInfo4Open(vendorStoreID, userName, params)
// }

// func (p *PurchaseHandler) EnableAutoAcceptOrder(vendorStoreID string, isEnabled bool) error {
// 	_, err := api.JdAPI.UpdateStoreConfig4Open(vendorStoreID, isEnabled)
// 	return err
// }

// func (p *PurchaseHandler) OpenStore(vendorStoreID string, userName string) error {
// 	params := map[string]interface{}{
// 		"closeStatus": 0,
// 		"storeNotice": "",
// 	}
// 	return api.JdAPI.UpdateStoreInfo4Open(vendorStoreID, userName, params)
// }

// func (p *PurchaseHandler) CloseStore(vendorStoreID, closeNotice, userName string) error {
// 	params := map[string]interface{}{
// 		"closeStatus": 1,
// 		"storeNotice": closeNotice,
// 	}
// 	return api.JdAPI.UpdateStoreInfo4Open(vendorStoreID, userName, params)
// }

///////////////////////
func (p *PurchaseHandler) GetAllStoreIDsFromRemote() ([]string, error) {
	result, err := api.JdAPI.GetStationsByVenderId()
	return result, err
}

func (p *PurchaseHandler) GetAllStoresFromRemote() ([]*model.Store, error) {
	ids, err := p.GetAllStoreIDsFromRemote()
	if err == nil {
		retVal := make([]*model.Store, len(ids))
		for index, id := range ids {
			store, err2 := p.ReadStore(id)
			if err2 == nil {
				retVal[index] = store
			} else {
				return nil, err2
			}
		}
		return retVal, nil
	}
	return nil, err
}

func (p *PurchaseHandler) RefreshAllStoresID(ctx *jxcontext.Context, parentTask tasksch.ITask, isAsync bool) (hint string, err error) {
	globals.SugarLogger.Debugf("jd RefreshAllStoresID")
	const stepCount = 3
	var stores []*tJdStoreInfo
	db := dao.GetDB()
	rootTask := tasksch.NewSeqTask("jd RefreshAllStoresID", ctx.GetUserName(), func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
		switch step {
		case 0:
			err = dao.GetRows(db, &stores, `
			SELECT t1.*, t2.vendor_store_id
			FROM store t1
			JOIN store_map t2 ON t1.id = t2.store_id AND t2.deleted_at = ? AND t2.vendor_id = ?
			WHERE t1.deleted_at = ?
			`, utils.DefaultTimeValue, model.VendorIDJD, utils.DefaultTimeValue)
		default:
			taskName := "jd RefreshAllStoresID update outSystemId"
			if step != stepCount-1 {
				taskName = "jd RefreshAllStoresID update to uuid"
			}
			task1 := tasksch.NewParallelTask(taskName, nil, ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
				store := batchItemList[0].(*tJdStoreInfo)
				storeParams := map[string]interface{}{
					"outSystemId": utils.Int2Str(int(store.ID)),
				}
				if step != stepCount-1 {
					storeParams["outSystemId"] = utils.GetUUID()
				}
				if true { //globals.EnableStoreWrite {
					err = api.JdAPI.UpdateStoreInfo4Open(store.VendorStoreID, ctx.GetUserName(), storeParams)
				}
				return nil, err
			}, stores)
			task.AddChild(task1).Run()
			_, err = task1.GetResult(0)
		}
		return nil, err
	}, stepCount)

	ctx.SetTaskOrAddChild(rootTask, parentTask)
	rootTask.Run()
	if !isAsync {
		_, err = rootTask.GetResult(0)
	}
	return rootTask.ID, err
}

// func JdRange2JxRange(jdRanges string) (jxRanges string) {
// 	coords := strings.Split(jdRanges, ";")
// 	intCoords := []string{}
// 	for _, coord := range coords {
// 		items := strings.Split(coord, ",")
// 		if len(items) == 2 {
// 			lng := jxutils.StandardCoordinate2Int(utils.Str2Float64(items[0]))
// 			lat := jxutils.StandardCoordinate2Int(utils.Str2Float64(items[1]))
// 			intCoords = append(intCoords, fmt.Sprintf("%d,%d", lng, lat))
// 		}
// 	}
// 	return strings.Join(intCoords, ";")
// }

// func JxRange2JdRange(jxRanges string) (jdRanges string) {
// 	coords := strings.Split(jxRanges, ";")
// 	intCoords := []string{}
// 	for _, coord := range coords {
// 		items := strings.Split(coord, ",")
// 		if len(items) == 2 {
// 			lng := jxutils.IntCoordinate2Standard(int(utils.Str2Int64(items[0])))
// 			lat := jxutils.IntCoordinate2Standard(int(utils.Str2Int64(items[1])))
// 			intCoords = append(intCoords, fmt.Sprintf("%f,%f", lng, lat))
// 		}
// 	}
// 	return strings.Join(intCoords, ";")
// }

func JdDeliveryType2Jx(deliveryType int) int8 {
	if deliveryType == 2938 {
		return scheduler.StoreDeliveryTypeByStore
	} else if deliveryType == 9966 {
		return scheduler.StoreDeliveryTypeCrowdSourcing
	}
	return scheduler.StoreDeliveryTypeByPlatform
}