package permisgen

import (
	"Cold_Logistic/internal/server/infra/dao"
	"Cold_Logistic/internal/server/infra/models"
	"context"
)

type RegionFiled struct {
	ParentId int            `json:"parentId"`
	Id       int            `json:"id"`
	Name     string         `json:"name"`
	Level    int            `json:"level"`
	Sort     int            `json:"sort"`
	Children []*RegionFiled `json:"children"`
}

func buildRegionTree(result []*RegionFiled, all []models.Region) []*RegionFiled {
	for _, v := range all {
		if v.ParentId == 0 {
			result = append(result, &RegionFiled{
				Id:       v.Id,
				Name:     v.Name,
				Level:    v.Level,
				Sort:     v.Sort,
				Children: make([]*RegionFiled, 0),
			})
			continue
		}

		for _, r := range result {
			if r.Id == v.ParentId {
				r.Children = append(r.Children, &RegionFiled{
					ParentId: v.ParentId,
					Id:       v.Id,
					Name:     v.Name,
					Level:    v.Level,
					Sort:     v.Sort,
					Children: make([]*RegionFiled, 0),
				})
				break
			}

			buildRegionTree(r.Children, []models.Region{v})
		}

	}

	return result
}

type RegionGen struct {
	store *dao.DataStore
}

func NewRegionGen(store *dao.DataStore) *RegionGen {
	return &RegionGen{store: store}
}

// 110000
func (r *RegionGen) Run(ctx context.Context, tree []*RegionFiled) error {
	for _, v := range tree {
		if err := r.Gen(ctx, v, 0); err != nil {
			return err
		}
	}
	return nil
}

func (r *RegionGen) Gen(ctx context.Context, d *RegionFiled, parentId int) error {
	g := &models.Region{
		Id:          0,
		Name:        d.Name,
		Level:       d.Level,
		Sort:        d.Sort,
		ParentId:    parentId,
		IsProtected: 1,
	}
	if err := r.store.Region().Create(ctx, g); err != nil {
		return err
	}

	if len(d.Children) > 0 {
		for _, v := range d.Children {
			if err := r.Gen(ctx, v, g.Id); err != nil {
				return err
			}
		}
	}
	return nil
}