package service

import (
	"pure-admin/global"
	"pure-admin/model"
	"pure-admin/model/request"
)

func UpdateCategory(id uint, name string) error {
	err := global.MG_DB.Model(&model.TbCategory{}).Where("id = ?", id).Update("name", name).Error

	if err != nil {
		return err
	}
	return nil
}

type CategoryValue struct {
	Id   int64  `json:"id"`
	Name string `json:"name"`
}

type CategoryItem struct {
	Id    int64         `json:"id"`
	One   CategoryValue `json:"one"`
	Two   CategoryValue `json:"two"`
	Three CategoryValue `json:"three"`
	Four  CategoryValue `json:"four"`
	Five  CategoryValue `json:"five"`
}

func ListCategoryMap() (m map[int64]*model.CategoryParentTree, err error) {
	var all []model.TbCategory
	m = make(map[int64]*model.CategoryParentTree)
	err = global.MG_DB.Model(&model.TbCategory{}).Where("`status` = 1").Order("layer DESC").Find(&all).Error

	if err != nil {
		return nil, err
	}
	
	for _, v := range all {
		m[int64(v.ID)] = &model.CategoryParentTree{v, nil}
	}
	return m, nil
}

func GetCategoryTree(id int64) (vos CategoryItem, err error) {
	var v model.TbCategory
	db := global.MG_DB.Model(&model.TbCategory{}).Where("`status` = 1").Order("layer DESC")

	err = db.Order("layer DESC").First(&v).Error
	if err != nil {
		return
	}
	m, err := ListCategoryMap()
	if err != nil {
		return
	}

	tmps := make([]model.CategoryParentTree, 0)
	var cp = model.CategoryParentTree{v, nil}
	_ = getCategoryParent(&cp, m)
	var item = CategoryItem{
		Id: int64(v.ID),
	}
	if cp.Parent != nil {
		transferCategoryParents(&cp, &tmps)
	} else {
		item.One = CategoryValue{
			Id:   int64(v.ID),
			Name: v.Name,
		}
	}
	for _, v := range tmps {
		switch v.Layer {
		case 5:
			item.Five = CategoryValue{
				Id:   int64(v.ID),
				Name: v.Name,
			}
		case 4:
			item.Four = CategoryValue{
				Id:   int64(v.ID),
				Name: v.Name,
			}
		case 3:
			item.Three = CategoryValue{
				Id:   int64(v.ID),
				Name: v.Name,
			}
		case 2:
			item.Two = CategoryValue{
				Id:   int64(v.ID),
				Name: v.Name,
			}
		case 1:
			item.One = CategoryValue{
				Id:   int64(v.ID),
				Name: v.Name,
			}
		}
	}

	return item, nil
}

func ListCategoryTree(req request.ListCategoryPage) (vos []CategoryItem, total int64, err error) {
	offset := req.PageSize * (req.Page - 1)
	var list []model.TbCategory
	db := global.MG_DB.Model(&model.TbCategory{}).Where("`status` = 1")
	
	if req.One != ""{
		db = db.Where("name LIKE ? AND layer=1", "%"+req.One+"%")
	}
	if req.Two != ""{
		db = db.Where("name LIKE ? AND layer=2", "%"+req.Two+"%")
	}
	if req.Three != ""{
		db = db.Where("name LIKE ? AND layer=3", "%"+req.Three+"%")
	}
	if req.Four != ""{
		db = db.Where("name LIKE ? AND layer=4", "%"+req.Four+"%")
	}
	if req.Five != ""{
		db = db.Where("name LIKE ? AND layer=5", "%"+req.Five+"%")
	}
	err = db.Count(&total).Error
	if err != nil {
		return nil, 0, err
	}
	err = db.Offset(offset).Order("id DESC").Limit(req.PageSize).Find(&list).Error
	if err != nil {
		return nil, 0, err
	}
	m, err := ListCategoryMap()
	if err != nil {
		return nil, 0, err
	}

	vos = make([]CategoryItem, 0)

	for _, v := range list {
		
		tmps := make([]model.CategoryParentTree, 0)
		var cp = model.CategoryParentTree{v, nil}
		_ = getCategoryParent(&cp, m)
		var item = CategoryItem{
			Id: int64(v.ID),
		}
		if cp.Parent != nil {
			transferCategoryParents(&cp, &tmps)
		} else {
			item.One = CategoryValue{
				Id:   int64(v.ID),
				Name: v.Name,
			}
		}
		for _, v := range tmps {
			switch v.Layer {
			case 5:
				item.Five = CategoryValue{
					Id:   int64(v.ID),
					Name: v.Name,
				}
			case 4:
				item.Four = CategoryValue{
					Id:   int64(v.ID),
					Name: v.Name,
				}
			case 3:
				item.Three = CategoryValue{
					Id:   int64(v.ID),
					Name: v.Name,
				}
			case 2:
				item.Two = CategoryValue{
					Id:   int64(v.ID),
					Name: v.Name,
				}
			case 1:
				item.One = CategoryValue{
					Id:   int64(v.ID),
					Name: v.Name,
				}
			}
		}
		vos = append(vos, item)
	}

	return vos, total, nil
}

func getCategoryParent(v *model.CategoryParentTree, m map[int64]*model.CategoryParentTree) (err error) {
	if v==nil || v.Pid == 0 {
		return nil
	}
	v.Parent = m[int64(v.Pid)]

	err = getCategoryParent(v.Parent, m)
	return err
}

func transferCategoryParents(info *model.CategoryParentTree, list *[]model.CategoryParentTree) {
	if info.ID != 0 {
		*list = append(*list, *info)
		if info.Parent != nil {
			transferCategoryParents(info.Parent, list)
		}
	}
}

func DeleteCategory(ids []int) error {
	var category model.TbCategory
	err := global.MG_DB.Where(" id IN (?)", ids).Delete(&category).Error
	return err
}

func CreateCategory(name string, pid, layer int) error {
	global.MG_DB.Model(&model.TbCategory{}).Where("id = ?", pid).Update("is_leaf", false)
	err := global.MG_DB.Create(&model.TbCategory{
		Name:   name,
		Layer:  layer,
		Pid:    uint(pid),
		IsLeaf: true,
		Status: 1,
	}).Error
	return err
}

func ListCategoryChildren(pid int) (list []model.TbCategory, err error) {
	err = global.MG_DB.Model(&model.TbCategory{}).Where("pid = ?", pid).Find(&list).Error
	return list, err
}