package cms

import (
	"errors"
	"strconv"

	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/jxutils"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/model/dao"
)

type SkuNameExt struct {
	model.SkuName
	Skus string `orm:"size(2000)" json:"skus"`
}

type SkuNamesInfo struct {
	TotalCount int           `json:"totalCount"`
	SkuNames   []*SkuNameExt `json:"skuNames"`
}

var (
	ErrInputCatsDoesntMatch = errors.New("输入的类别列表不合法，需要输入一个父ID下的所有子类别")
)

// parentID 为-1表示所有
func GetVendorCategories(vendorID int, parentID int) (vendorCats []*model.SkuVendorCategory, err error) {
	cond := map[string]interface{}{
		model.FieldVendorID: vendorID,
	}
	if parentID != -1 {
		cond[model.FieldParentID] = parentID
	}
	return vendorCats, dao.GetEntities(nil, &vendorCats, cond, false)
}

func GetSkuMetaInfo() (*model.SkuMetaInfo, error) {
	return &model.SkuMetaInfo{
		Units:     model.UnitNames,
		SpecUnits: model.SpecUnitNames,
	}, nil
}

// parentID 为-1表示所有
func GetCategories(parentID int) (cats []*model.SkuCategory, err error) {
	if parentID == -1 {
		return cats, dao.GetEntities(nil, &cats, nil, false)
	}
	return cats, dao.GetEntities(nil, &cats, utils.Params2Map(model.FieldParentID, parentID), false)
}

func AddCategory(cat *model.SkuCategory, userName string) (outCat *model.SkuCategory, err error) {
	cat.ID = 0
	cat.JdSyncStatus = model.SyncFlagNewMask
	cat.DeletedAt = utils.DefaultTimeValue
	if err = dao.CreateEntity(nil, cat); err == nil {
		outCat = cat
		err = CurVendorSync.SyncCategory(cat.ID, false, userName)
	}
	return outCat, err
}

func UpdateCategory(categoryID int, payload map[string]interface{}, userName string) (num int64, err error) {
	cat := &model.SkuCategory{}
	cat.ID = categoryID
	valid := jxutils.NormalMakeMapByStructObject(payload, cat, userName)
	valid[model.FieldJdSyncStatus] = model.SyncFlagModifiedMask
	db := dao.GetDB()
	if num, err = dao.UpdateEntityByKV(db, cat, valid, nil); err == nil {
		err = CurVendorSync.SyncCategory(categoryID, false, userName)
	}
	return num, err
}

func ReorderCategories(parentID int, categoryIDs []int, userName string) (err error) {
	var cats []*model.SkuCategory
	parentCat := &model.SkuCategory{}
	parentCat.ID = parentID
	db := dao.GetDB()
	if err = dao.GetEntity(db, parentCat); err == nil {
		if err = dao.GetEntities(db, &cats, utils.Params2Map(model.FieldParentID, parentID), false); err == nil {
			catsLen := len(cats)
			if catsLen != len(categoryIDs) {
				return ErrInputCatsDoesntMatch
			}
			catsMap := make(map[int]*model.SkuCategory, catsLen)
			for _, cat := range cats {
				catsMap[cat.ID] = cat
			}
			for k, v := range categoryIDs {
				catsMap[v].Seq = k * 5
				// catsMap[v].JdSyncStatus = model.SyncFlagModifiedMask
				if _, err = dao.UpdateEntity(db, catsMap[v], "Seq"); err != nil {
					break
				}
			}
			if err == nil {
				err = GetPurchaseHandler(model.VendorIDJD).ReorderCategories(parentCat, userName)
			}
		}
	}
	return err
}

func DeleteCategory(categoryID int, isForce bool, userName string) (num int64, err error) {
	cat := &model.SkuCategory{}
	cat.ID = categoryID
	var countInfos []*struct{ Ct int }
	if err = dao.GetRows(nil, &countInfos, `
	SELECT COUNT(*) ct
	FROM sku t1
	WHERE t1.category_id = ?
	UNION ALL
	SELECT COUNT(*) ct
	FROM sku_name t1
	WHERE t1.category_id = ?
	UNION ALL
	SELECT COUNT(*) ct
	FROM sku_category t1
	WHERE t1.parent_id = ?
	`, categoryID, categoryID, categoryID, &countInfos); err == nil {
		if countInfos[0].Ct != 0 {
			return 0, errors.New("还有商品使用此类别，不能删除")
		} else if countInfos[1].Ct != 0 {
			return 0, errors.New("还有商品名使用此类别，不能删除")
		} else if countInfos[2].Ct != 0 {
			return 0, errors.New("还有商品类别使用此类别，不能删除")
		}
		if num, err = dao.DeleteEntity(nil, cat, nil, userName, utils.Params2Map(model.FieldJdSyncStatus, model.SyncFlagDeletedMask)); err == nil && num == 1 {
			err = CurVendorSync.SyncCategory(cat.ID, false, userName)
		}
	}
	return num, err
}

func GetSkuNames(keyword string, params map[string]interface{}, offset, pageSize int) (skuNamesInfo *SkuNamesInfo, err error) {
	sql := `
	FROM sku_name t1
	JOIN sku t2 ON t1.id = t2.name_id
	WHERE`
	sqlParams := make([]interface{}, 0)
	if keyword != "" {
		keywordLike := "%" + keyword + "%"
		sql += " (t1.name LIKE ? OR t1.prefix LIKE ? OR t1.comment LIKE ?"
		sqlParams = append(sqlParams, keywordLike, keywordLike, keywordLike)

		if keywordInt64, err2 := strconv.ParseInt(keyword, 10, 64); err2 == nil {
			sql += " OR t2.jd_id = ? OR t1.id = ? OR t1.category_id = ?"
			sqlParams = append(sqlParams, keywordInt64, keywordInt64, keywordInt64)
		}
		sql += ")"
	} else {
		sql += " 1 = 1"
	}

	if params["id"] != nil {
		sql += " AND t1.id = ?"
		sqlParams = append(sqlParams, params["id"].(int))
	}
	if params["categoryID"] != nil {
		sql += " AND t1.category_id = ?"
		sqlParams = append(sqlParams, params["categoryID"].(int))
	}
	if params["jdID"] != nil {
		sql += " AND t1.jd_id = ?"
		sqlParams = append(sqlParams, params["jdID"].(int))
	}
	if params["name"] != nil {
		sql += " AND t1.name LIKE ?"
		sqlParams = append(sqlParams, "%"+params["name"].(string)+"%")
	}
	if params["prefix"] != nil {
		sql += " AND t1.prefix LIKE ?"
		sqlParams = append(sqlParams, "%"+params["prefix"].(string)+"%")
	}
	if params["unit"] != nil {
		sql += " AND t1.unit = ?"
		sqlParams = append(sqlParams, params["unit"].(string))
	}
	if params["placeCode"] != nil {
		sql += " AND (SELECT COUNT(*) FROM sku_name_place_bind bind WHERE bind.sku_name_id = t1.id AND bind.place_code = ?) > 0"
		sqlParams = append(sqlParams, params["placeCode"].(int))
	}
	if params["isGlobal"] != nil {
		if params["isGlobal"].(bool) {
			sql += " AND t1.is_global = 1"
		} else {
			sql += " AND t1.is_global = 0"
		}
	}
	if params["fromStatus"] != nil {
		fromStatus := params["fromStatus"].(int)
		toStatus := fromStatus
		if params["toStatus"] != nil {
			toStatus = params["toStatus"].(int)
		}
		sql += " AND t1.status >= ? AND t1.status <= ?"
		sqlParams = append(sqlParams, fromStatus, toStatus)
	}
	sql += `
	GROUP BY
	t1.id,
	t1.created_at,
	t1.updated_at,
	t1.last_operator,
	t1.prefix,
	t1.name,
	t1.comment,
	t1.brand_id,
	t1.category_id,
	t1.status,
	t1.is_global,
	t1.unit,
	t1.price,
	t1.img,
	t1.elm_img_hash_code
	`
	db := dao.GetDB()
	sqlData := `
		SELECT
		SQL_CALC_FOUND_ROWS
		t1.id,
		t1.created_at,
		t1.updated_at,
		t1.last_operator,
		t1.prefix,
		t1.name,
		t1.comment,
		t1.brand_id,
		t1.category_id,
		t1.status,
		t1.is_global,
		t1.unit,
		t1.price,
		t1.img,
		t1.elm_img_hash_code, CONCAT("[", GROUP_CONCAT(CONCAT('{"id":', t2.id, ',"specQuality":', t2.spec_quality, ',"specUnit":"', t2.spec_unit, '","weight":', t2.weight, ',"jdID":', t2.jd_id, "}")), "]") skus
		` + sql + `
	ORDER BY t1.id
	LIMIT ? OFFSET ?`
	if pageSize == 0 {
		pageSize = model.DefPageSize
	}
	if offset < 0 {
		offset = 0
	}
	sqlParams = append(sqlParams, pageSize, offset)
	skuNamesInfo = &SkuNamesInfo{}
	if err = dao.GetRows(db, &skuNamesInfo.SkuNames, sqlData, sqlParams...); err == nil {
		countInfo := &struct{ Ct int }{}
		if err = dao.GetRow(db, countInfo, "SELECT FOUND_ROWS() ct"); err == nil {
			skuNamesInfo.TotalCount = countInfo.Ct
		}
	}
	return skuNamesInfo, err
}