package converter

import (
	"github.com/tidbcloud/AgentTeam/internal/api/dto"
	"github.com/tidbcloud/AgentTeam/internal/service/roles"
)

func ToRoleCapabilities(capabilities roles.Capabilities) dto.RoleCapabilities {
	return dto.RoleCapabilities{
		Enabled:                   capabilities.Enabled,
		PresetRoles:               capabilities.PresetRoles,
		MyRoles:                   capabilities.MyRoles,
		Realization:               capabilities.Realization,
		RolePackage:               capabilities.RolePackage,
		RolePackageDisabledReason: capabilities.RolePackageDisabledReason,
		DisabledReason:            capabilities.DisabledReason,
	}
}

func ToRole(role roles.Role) dto.Role {
	return dto.Role{
		ID:                    role.ID,
		WorkspaceID:           role.WorkspaceID,
		Source:                role.Source,
		Visibility:            role.Visibility,
		Slug:                  role.Slug,
		Name:                  role.Name,
		Description:           role.Description,
		Locale:                role.Locale,
		Scenario:              role.Scenario,
		Icon:                  role.Icon,
		Tags:                  append([]string(nil), role.Tags...),
		Definition:            role.Definition,
		RuntimeHints:          ToRoleRuntimeHints(role.RuntimeHints),
		RoleVersionID:         role.RoleVersionID,
		SourcePresetID:        role.SourcePresetID,
		SourcePresetVersion:   role.SourcePresetVersion,
		SourcePresetVersionID: role.SourcePresetVersionID,
		SourceAgentID:         role.SourceAgentID,
		IsActive:              role.IsActive,
		Role:                  role.Role,
		CanManage:             role.CanManage,
		OwnerID:               role.OwnerID,
		Editable:              role.Editable,
		Provenance:            ToRoleProvenance(role.Provenance),
		RolePackage:           ToRolePackage(role.RolePackage),
		RolePackageManifest:   ToRolePackageManifest(role.RolePackageManifest),
		CreatedBy:             role.CreatedBy,
		UpdatedBy:             role.UpdatedBy,
		CreatedAt:             timeOrEmpty(role.CreatedAt),
		UpdatedAt:             timeOrEmpty(role.UpdatedAt),
	}
}

func ToRoles(roles []roles.Role) []dto.Role {
	out := make([]dto.Role, 0, len(roles))
	for _, role := range roles {
		out = append(out, ToRole(role))
	}
	return out
}

func ToRoleListResponse(page roles.Page) dto.RoleListResponse {
	return dto.RoleListResponse{Items: ToRoles(page.Items), Page: page.Page, PerPage: page.PerPage, Total: page.Total, HasMore: page.HasMore}
}

func ToRoleVersionListResponse(page roles.RoleVersionPage) dto.RoleVersionListResponse {
	items := make([]dto.RoleVersion, 0, len(page.Items))
	for _, version := range page.Items {
		items = append(items, dto.RoleVersion{
			ID: version.ID, Version: version.Version, ContentID: version.ContentID, ContentVersionID: version.ContentVersionID,
			CreatedBy: version.CreatedBy, CreatedAt: timeOrEmpty(version.CreatedAt), Active: version.Active,
		})
	}
	return dto.RoleVersionListResponse{Items: items, Page: page.Page, PerPage: page.PerPage, HasMore: page.HasMore}
}

func ToRoleProvenance(provenance roles.RoleProvenance) dto.RoleProvenance {
	return dto.RoleProvenance{Kind: provenance.Kind, Ref: provenance.Ref, Version: provenance.Version}
}

func ToRolePackage(pkg roles.RolePackage) dto.RolePackage {
	unresolved := make([]dto.RolePackageUnresolved, 0, len(pkg.Unresolved))
	for _, item := range pkg.Unresolved {
		unresolved = append(unresolved, dto.RolePackageUnresolved{Section: item.Section, Name: item.Name, Reason: item.Reason, Required: item.Required})
	}
	return dto.RolePackage{Portable: pkg.Portable, Sections: append([]string(nil), pkg.Sections...), NonPortable: append([]string(nil), pkg.NonPortable...), Unresolved: unresolved}
}

func ToRolePackageManifest(manifest roles.RolePackageManifest) dto.RolePackageManifest {
	items := make([]dto.RolePackageManifestItem, 0, len(manifest.Items))
	for _, item := range manifest.Items {
		items = append(items, dto.RolePackageManifestItem{Type: item.Type, Name: item.Name, Description: item.Description, Required: item.Required, Action: item.Action, ResourceID: item.ResourceID, AccessLevel: item.AccessLevel, Branch: item.Branch, Content: item.Content})
	}
	return dto.RolePackageManifest{Items: items}
}

func ToRoleRuntimeHints(hints roles.RuntimeHints) dto.RoleRuntimeHints {
	return dto.RoleRuntimeHints{Runtime: hints.Runtime, Model: hints.Model, ReasoningEffort: hints.ReasoningEffort, SuggestedName: hints.SuggestedName}
}

func ToRoleRealizationResponse(result roles.RealizationResult) dto.RoleRealizationResponse {
	items := make([]dto.RoleRealizationItem, 0, len(result.Items))
	for _, item := range result.Items {
		items = append(items, dto.RoleRealizationItem{ManifestItemType: item.ManifestItemType, ManifestItemName: item.ManifestItemName, Action: item.Action, Status: item.Status, ResourceID: item.ResourceID, AccessLevel: item.AccessLevel, Branch: item.Branch, Message: item.Message, Required: item.Required})
	}
	return dto.RoleRealizationResponse{RoleID: result.RoleID, AgentID: result.AgentID, DryRun: result.DryRun, Apply: result.Apply, Items: items}
}

func ToRoleRealizationImpactResponse(impact roles.RealizationImpact) dto.RoleRealizationImpactResponse {
	return dto.RoleRealizationImpactResponse{
		ManagedMemories:   impact.ManagedMemories,
		SkillRepositories: impact.SkillRepositories,
	}
}