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.ListAPIs(ctx, req.Page, req.PageSize, &biz.API{Path: req.Path, Description: req.Description, APIGroup: req.APIGroup, Method: req.Method, OrderKey: req.OrderKey, Desc: req.Desc})
	if err != nil {
		return nil, 0, err
	}
	return apiResponses(items), total, nil
}

func (s *AccessService) AllAPI(ctx context.Context, strict bool) ([]*dto.APIResponse, error) {
	items, _, err := s.uc.ListAPIs(ctx, 0, 0, &biz.API{StrictAll: strict})
	if err != nil {
		return nil, err
	}
	return apiResponses(items), nil
}

func (s *AccessService) CreateAPIRequest(ctx context.Context, req *dto.APIRequest) (*dto.APIResponse, error) {
	value := apiDomain(req)
	if err := s.uc.CreateAPI(ctx, value); err != nil {
		return nil, err
	}
	return apiResponse(value), nil
}
func (s *AccessService) UpdateAPIRequest(ctx context.Context, req *dto.APIRequest) error {
	return s.uc.UpdateAPI(ctx, apiDomain(req))
}
func (s *AccessService) FindAPIResponse(ctx context.Context, id uint) (*dto.APIResponse, error) {
	value, err := s.uc.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.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.SetPolicyPaths(ctx, req.AuthorityID, paths)
}
func (s *AccessService) PolicyPathResponses(ctx context.Context, authorityID uint) ([]dto.PolicyPathRequest, error) {
	items, err := s.uc.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 {
		routes[i].Path = s.NormalizeRoutePath(routes[i].Path)
		if routes[i].APIGroup == "" || routes[i].Description == "" {
			group, description := routeMetadata(routes[i].Method, routes[i].Path)
			if routes[i].APIGroup == "" {
				routes[i].APIGroup = group
			}
			if routes[i].Description == "" {
				routes[i].Description = description
			}
		}
		items = append(items, apiDomain(&routes[i]))
	}
	return s.SyncAPIs(ctx, items)
}

func apiDTO(v *biz.API) map[string]any {
	return map[string]any{"ID": v.ID, "CreatedAt": v.CreatedAt, "UpdatedAt": v.UpdatedAt, "DeletedAt": nil, "path": v.Path, "description": v.Description, "apiGroup": v.APIGroup, "method": v.Method}
}
func (s *AccessService) DeleteAPIs(ctx context.Context, ids []uint) error {
	return s.uc.DeleteAPIs(ctx, ids)
}
func (s *AccessService) APIRoleIDs(ctx context.Context, path, method string) ([]uint, error) {
	return s.uc.APIRoleIDs(ctx, path, method)
}
func (s *AccessService) SetAPIRoles(ctx context.Context, path, method string, ids []uint) error {
	return s.uc.SetAPIRoles(ctx, path, method, ids)
}
func (s *AccessService) SyncAPIs(ctx context.Context, routes []*biz.API) (*dto.APISyncResponse, error) {
	diff, err := s.uc.SyncAPIs(ctx, routes)
	if err != nil {
		return nil, err
	}
	return &dto.APISyncResponse{NewAPIs: apiResponses(diff.Added), DeleteAPIs: apiResponses(diff.Deleted), IgnoreAPIs: apiResponses(diff.Ignored)}, nil
}
func (s *AccessService) SetAPIIgnored(ctx context.Context, path, method string, ignored bool) error {
	return s.uc.SetAPIIgnored(ctx, path, method, ignored)
}