package system

import (
	"context"
	"fmt"
	"time"

	"management/internal/erpserver/model/dto"
	"management/internal/erpserver/model/system"
	"management/internal/erpserver/repository"
)

type roleRepository struct {
	repo *repository.Repository
}

func NewRoleRepository(repo *repository.Repository) system.RoleRepository {
	return &roleRepository{
		repo: repo,
	}
}

func (r *roleRepository) Initialize(ctx context.Context) (*system.Role, error) {
	var count int64
	if err := r.repo.DB(ctx).Model(&system.Role{}).Count(&count).Error; err != nil {
		return nil, err
	}
	if count == 0 {
		obj := system.Role{
			Name:        "Company",
			DisplayName: "公司",
			Vip:         false,
			ParentID:    0,
			ParentPath:  ",0,",
			Status:      0,
			CreatedAt:   time.Now(),
			UpdatedAt:   time.Now(),
		}
		if err := r.Create(ctx, &obj); err != nil {
			return nil, err
		}

		obj1 := system.Role{
			Name:        "SuperAdmin",
			DisplayName: "超级管理员",
			Vip:         true,
			ParentID:    obj.ID,
			ParentPath:  fmt.Sprintf(",0,%d,", obj.ID),
			Status:      0,
			CreatedAt:   time.Now(),
			UpdatedAt:   time.Now(),
		}
		if err := r.Create(ctx, &obj1); err != nil {
			return nil, err
		}
		return &obj1, nil
	}

	var role system.Role
	err := r.repo.DB(ctx).Where("vip = ?", true).First(&role).Error
	if err != nil {
		return nil, err
	}
	return &role, nil
}

func (r *roleRepository) Create(ctx context.Context, obj *system.Role) error {
	return r.repo.DB(ctx).Create(obj).Error
}

func (r *roleRepository) Update(ctx context.Context, obj *system.Role) error {
	return r.repo.DB(ctx).Save(obj).Error
}

func (r *roleRepository) Get(ctx context.Context, id int32) (*system.Role, error) {
	var role system.Role
	err := r.repo.DB(ctx).Where("id = ?", id).First(&role).Error
	if err != nil {
		return nil, err
	}
	return &role, nil
}

func (r *roleRepository) All(ctx context.Context) ([]*system.Role, error) {
	var roles []*system.Role
	err := r.repo.DB(ctx).Find(&roles).Error
	if err != nil {
		return nil, err
	}
	return roles, nil
}

func (r *roleRepository) List(ctx context.Context, q dto.SearchDto) ([]*system.Role, int64, error) {
	query := r.repo.DB(ctx).
		Model(&system.Role{}).
		Where("created_at BETWEEN ? AND ?", q.SearchTimeBegin, q.SearchTimeEnd)
	if q.SearchID != 0 {
		query = query.Where("id = ?", q.SearchID)
	}
	if q.SearchParentID != 0 && q.SearchParentID != 1 {
		query = query.Where("parent_id = ?", q.SearchParentID)
	}
	if q.SearchName != "" {
		query = query.Where("name LIKE ?", "%"+q.SearchName+"%")
	}
	if q.SearchStatus != 9999 {
		query = query.Where("status = ?", q.SearchStatus)
	}

	var count int64
	err := query.Count(&count).Error
	if err != nil {
		return nil, 0, err
	}

	var departs []*system.Role
	err = query.
		Order("id DESC").
		Offset((q.Page - 1) * q.Rows).
		Limit(q.Rows).
		Find(&departs).Error
	if err != nil {
		return nil, 0, err
	}
	return departs, count, nil
}

func (r *roleRepository) RebuildParentPath(ctx context.Context) error {
	query := `UPDATE sys_role AS tm
	SET parent_path = (SELECT ',' || string_agg(cast(t.parent_id AS VARCHAR), ',') || ','
					   FROM (WITH RECURSIVE temp (id, parent_id) AS (SELECT id, tm.parent_id
																	 FROM sys_role
																	 WHERE id = tm.id
																	 UNION ALL
																	 SELECT sys_role.id, sys_role.parent_id
																	 FROM sys_role,
																		  temp
																	 WHERE sys_role.id = temp.parent_id)
							 SELECT id, parent_id
							 FROM temp
							 ORDER BY id) AS t)
	WHERE tm.status = 0;`
	return r.repo.DB(ctx).Exec(query).Error
}