package service

import (
	"context"

	"kra/internal/biz"
	"kra/internal/service/dto"
)

func apiDomain(value *dto.APIRequest) *biz.API {
	return &biz.API{ID: value.ID, Path: value.Path, Description: value.Description, APIGroup: value.APIGroup, Method: value.Method}
}

func apiResponse(value *biz.API) *dto.APIResponse {
	return &dto.APIResponse{ID: value.ID, CreatedAt: value.CreatedAt, UpdatedAt: value.UpdatedAt, DeletedAt: nil, Path: value.Path, Description: value.Description, APIGroup: value.APIGroup, Method: value.Method}
}

func apiResponses(items []*biz.API) []*dto.APIResponse {
	out := make([]*dto.APIResponse, 0, len(items))
	for _, item := range items {
		out = append(out, apiResponse(item))
	}
	return out
}

func (s *AccessService) ListAPI(ctx context.Context, req *dto.APIListRequest) ([]*dto.APIResponse, int64, error) {
	items, total, err := s.uc.Repo().ListAPIs(ctx, req.Page, req.PageSize, &biz.API{Path: req.Path, Description: req.Description, APIGroup: req.APIGroup, Method: req.Method})
	if err != nil {
		return nil, 0, err
	}
	return apiResponses(items), total, nil
}

func (s *AccessService) AllAPI(ctx context.Context) ([]*dto.APIResponse, error) {
	items, _, err := s.uc.Repo().ListAPIs(ctx, 1, 10000, nil)
	if err != nil {
		return nil, err
	}
	return apiResponses(items), nil
}

func (s *AccessService) CreateAPIRequest(ctx context.Context, req *dto.APIRequest) error {
	return s.uc.Repo().CreateAPI(ctx, apiDomain(req))
}
func (s *AccessService) UpdateAPIRequest(ctx context.Context, req *dto.APIRequest) error {
	return s.uc.Repo().UpdateAPI(ctx, apiDomain(req))
}
func (s *AccessService) FindAPIResponse(ctx context.Context, id uint) (*dto.APIResponse, error) {
	value, err := s.uc.Repo().FindAPI(ctx, id)
	if err != nil {
		return nil, err
	}
	return apiResponse(value), nil
}
func (s *AccessService) ApplyAPISyncRequest(ctx context.Context, req *dto.ApplyAPISyncRequest) error {
	added := make([]*biz.API, 0, len(req.NewAPIs))
	deleted := make([]*biz.API, 0, len(req.DeleteAPIs))
	for i := range req.NewAPIs {
		added = append(added, apiDomain(&req.NewAPIs[i]))
	}
	for i := range req.DeleteAPIs {
		deleted = append(deleted, apiDomain(&req.DeleteAPIs[i]))
	}
	return s.uc.Repo().ApplyAPISync(ctx, added, deleted)
}
func (s *AccessService) SetPolicyPathsRequest(ctx context.Context, req *dto.SetPolicyPathsRequest) error {
	paths := make([]*biz.API, 0, len(req.Infos))
	for _, value := range req.Infos {
		paths = append(paths, &biz.API{Path: value.Path, Method: value.Method})
	}
	return s.uc.Repo().SetPolicyPaths(ctx, req.AuthorityID, paths)
}
func (s *AccessService) PolicyPathResponses(ctx context.Context, authorityID uint) ([]dto.PolicyPathRequest, error) {
	items, err := s.uc.Repo().PolicyPaths(ctx, authorityID)
	if err != nil {
		return nil, err
	}
	out := make([]dto.PolicyPathRequest, 0, len(items))
	for _, item := range items {
		out = append(out, dto.PolicyPathRequest{Path: item.Path, Method: item.Method})
	}
	return out, nil
}
func (s *AccessService) SyncAPIResponses(ctx context.Context, routes []dto.APIRequest) (*dto.APISyncResponse, error) {
	items := make([]*biz.API, 0, len(routes))
	for i := range routes {
		items = append(items, apiDomain(&routes[i]))
	}
	return s.SyncAPIs(ctx, items)
}