package space

import (
	"allapp/api/router/middleware"
	"allapp/api/types"
	"allapp/db"
	"allapp/db/repo"
	"allapp/utils"
	"allapp/utils/errorx"
	"allapp/utils/requestx"
	"allapp/utils/responsex"
	"allapp/utils/uniqueid"
	"context"

	"github.com/gofiber/fiber/v3"
)

// CreateSpace 创建空间
func CreateSpace(c fiber.Ctx) error {
	dto := new(types.CreateSpaceDTO)
	vo := new(types.CreateSpaceVO)

	if err := requestx.BindAndValidate(c, dto); err != nil {
		return err
	}

	userID, err2 := middleware.GetUserID(c)

	if err2 != nil {
		return err2
	}

	var inviteCode string

	for {
		// 生成邀请码
		code := utils.GenerateCode(6)

		// 检查数据库是否存在

		_, err := db.Queries.GetSpaceByInviteCode(c.Context(), code)

		if err != nil {
			if errorx.IsNotFound(err) {
				inviteCode = code
				break
			} else {
				return err
			}
		}
	}

	spaceId := uniqueid.NextId()

	err := db.WithTx(c.Context(), func(q *repo.Queries) error {
		// 查询是否存在空间
		countSpaces, err3 := q.CountUserSpaces(c.Context(), userID)
		if err3 != nil {
			return err3
		}

		isDefault := 0

		if countSpaces == 0 {
			isDefault = 1
		}

		// 创建空间
		params := repo.InsertSpaceParams{
			ID:         spaceId,
			Name:       dto.Name,
			InviteCode: inviteCode,
			OwnerID:    userID,
		}

		err := q.InsertSpace(c.Context(), params)

		if err != nil {
			return err
		}

		// 将创建用户默认添加到该空间内
		spaceMemberParams := repo.InsertSpaceMemberParams{
			ID:         uniqueid.NextId(),
			SpaceID:    spaceId,
			UserID:     userID,
			Role:       0,
			IsDefault:  int16(isDefault),
			UserName:   dto.UserName,
			SortNumber: dto.SortNumber,
		}

		err = q.InsertSpaceMember(c.Context(), spaceMemberParams)
		if err != nil {
			return err
		}

		// 初始化记账
		err = initFinanceCategory(c.Context(), q, spaceId, userID)
		if err != nil {
			return err
		}

		return nil
	})

	if err != nil {
		return err
	}

	vo.SpaceId = spaceId
	vo.InviteCode = inviteCode

	return responsex.OK(c, vo)
}

func ListUserSpaces(c fiber.Ctx) error {
	vo := new(types.ListSpacesVO)

	userID, err := middleware.GetUserID(c)

	if err != nil {
		return err
	}

	rows, err := db.Queries.ListSpacesByUserId(c.Context(), userID)

	if err != nil {
		return err
	}

	userSpaces := make([]types.UserSpace, 0, len(rows))

	for _, row := range rows {
		userSpaces = append(userSpaces, types.UserSpace{
			Id:          row.ID,
			OwnerId:     row.OwnerID,
			Name:        row.Name,
			Role:        row.Role,
			MemberCount: row.MemberCount,
			IsDefault:   row.IsDefault,
			UserName:    row.UserName,
			SortNumber:  row.SortNumber,
		})
	}

	vo.Spaces = userSpaces

	return responsex.OK(c, vo)
}

func initFinanceCategory(ctx context.Context, q *repo.Queries, spaceId int64, userId int64) error {
	categoryDefaults, err := q.ListFinanceCategoryDefault(ctx)
	if err != nil {
		return err
	}
	if len(categoryDefaults) == 0 {
		return nil
	}

	categorySpaces := make([]repo.BatchInsertFinanceCategorySpaceParams, 0, len(categoryDefaults))

	for _, sysCat := range categoryDefaults {
		categorySpaces = append(categorySpaces, repo.BatchInsertFinanceCategorySpaceParams{
			ID:         uniqueid.NextId(),
			SpaceID:    spaceId,
			Name:       sysCat.Name,
			Icon:       sysCat.Icon,
			Type:       sysCat.Type,
			SortNumber: sysCat.SortNumber,
			CreateBy:   userId,
			UpdateBy:   userId,
		})
	}

	if _, err := q.BatchInsertFinanceCategorySpace(ctx, categorySpaces); err != nil {
		return err
	}

	return nil
}