package converter

import (
	"github.com/tidbcloud/AgentTeam/internal/api/dto"
	"github.com/tidbcloud/AgentTeam/internal/coredb"
	"github.com/tidbcloud/AgentTeam/internal/store/admin"
	"github.com/tidbcloud/AgentTeam/internal/store/identity"
	"github.com/tidbcloud/AgentTeam/internal/store/plan"
)

// ToAdminOverview converts a store admin overview to a DTO admin overview.
// Migrated from admin/presenters.go.
func ToAdminOverview(overview admin.AdminOverview) dto.AdminOverview {
	return dto.AdminOverview{
		WindowHours:             overview.WindowHours,
		TotalWorkspaces:         overview.TotalWorkspaces,
		NewWorkspaces:           overview.NewWorkspaces,
		ActiveWorkspaces:        overview.ActiveWorkspaces,
		TotalUsers:              overview.TotalUsers,
		VerifiedUsers:           overview.VerifiedUsers,
		ActiveUsers:             overview.ActiveUsers,
		RecentLoginUsers:        overview.RecentLoginUsers,
		TotalAgents:             overview.TotalAgents,
		ActiveAgents:            overview.ActiveAgents,
		TotalMachines:           overview.TotalMachines,
		OnlineMachines:          overview.OnlineMachines,
		PendingWorkspaceInvites: overview.PendingWorkspaceInvites,
		MessageCount:            overview.MessageCount,
		HumanMessageCount:       overview.HumanMessageCount,
		AgentMessageCount:       overview.AgentMessageCount,
	}
}

// ToAdminWorkspaceSummary converts one store admin workspace row into the API DTO shape.
func ToAdminWorkspaceSummary(item admin.AdminWorkspaceSummary) dto.AdminWorkspaceSummary {
	return dto.AdminWorkspaceSummary{
		ID:                 item.ID,
		Slug:               item.Slug,
		Name:               item.Name,
		OwnerUserID:        item.OwnerUserID,
		OwnerEmail:         item.OwnerEmail,
		OwnerDisplayName:   item.OwnerDisplayName,
		CreatedAt:          item.CreatedAt,
		HumanMemberCount:   item.HumanMemberCount,
		AgentCount:         item.AgentCount,
		MachineCount:       item.MachineCount,
		ChannelCount:       item.ChannelCount,
		PendingInviteCount: item.PendingInviteCount,
		MessageCount:       item.MessageCount,
		LastMessageAt:      item.LastMessageAt,
		LastHumanMessageAt: item.LastHumanMessageAt,
		LastAgentMessageAt: item.LastAgentMessageAt,
	}
}

// ToAdminWorkspaceSummaries converts store admin workspace rows into API DTO rows.
func ToAdminWorkspaceSummaries(items []admin.AdminWorkspaceSummary) []dto.AdminWorkspaceSummary {
	if len(items) == 0 {
		return []dto.AdminWorkspaceSummary{}
	}
	result := make([]dto.AdminWorkspaceSummary, 0, len(items))
	for _, item := range items {
		result = append(result, ToAdminWorkspaceSummary(item))
	}
	return result
}

// ToAdminUserSummary converts one store admin user row into the API DTO shape.
func ToAdminUserSummary(item admin.AdminUserSummary) dto.AdminUserSummary {
	return dto.AdminUserSummary{
		ID:                  item.ID,
		Email:               item.Email,
		Name:                item.Name,
		DisplayName:         item.DisplayName,
		IsAdmin:             item.IsAdmin,
		EmailVerified:       item.EmailVerified,
		CreatedAt:           item.CreatedAt,
		WorkspaceCount:      item.WorkspaceCount,
		OwnedWorkspaceCount: item.OwnedWorkspaceCount,
		LastLoginAt:         item.LastLoginAt,
		LastHumanMessageAt:  item.LastHumanMessageAt,
	}
}

// ToAdminUserSummaries converts store admin user rows into API DTO rows.
func ToAdminUserSummaries(items []admin.AdminUserSummary) []dto.AdminUserSummary {
	if len(items) == 0 {
		return []dto.AdminUserSummary{}
	}
	result := make([]dto.AdminUserSummary, 0, len(items))
	for _, item := range items {
		result = append(result, ToAdminUserSummary(item))
	}
	return result
}

// ToAdminRegistrationAllowlistEntry converts a store registration allowlist row to its API DTO shape.
func ToAdminRegistrationAllowlistEntry(entry identity.RegistrationAllowlistEntry) dto.AdminRegistrationAllowlistEntry {
	return dto.AdminRegistrationAllowlistEntry{
		ID:                   entry.ID,
		Pattern:              entry.Pattern,
		Reason:               entry.Reason,
		CreatedByUserID:      entry.CreatedByUserID,
		CreatedByEmail:       entry.CreatedByEmail,
		CreatedByDisplayName: entry.CreatedByDisplayName,
		CreatedAt:            entry.CreatedAt,
		UpdatedAt:            entry.UpdatedAt,
		ExpiresAt:            entry.ExpiresAt,
		DisabledAt:           entry.DisabledAt,
	}
}

// ToAdminRegistrationAllowlistEntries converts store registration allowlist rows to API DTO rows.
func ToAdminRegistrationAllowlistEntries(entries []identity.RegistrationAllowlistEntry) []dto.AdminRegistrationAllowlistEntry {
	if len(entries) == 0 {
		return []dto.AdminRegistrationAllowlistEntry{}
	}
	result := make([]dto.AdminRegistrationAllowlistEntry, 0, len(entries))
	for _, entry := range entries {
		result = append(result, ToAdminRegistrationAllowlistEntry(entry))
	}
	return result
}

func metricMapToStrings(values map[plan.MetricKey]int64) map[string]int64 {
	if len(values) == 0 {
		return map[string]int64{}
	}
	result := make(map[string]int64, len(values))
	for key, value := range values {
		result[string(key)] = value
	}
	return result
}

// ToOrganizationPlanView converts a store organization plan view to its API DTO shape.
func ToOrganizationPlanView(view plan.OrganizationPlanView) dto.OrganizationPlanView {
	return dto.OrganizationPlanView{
		OrganizationID: view.OrganizationID,
		PlanKey:        string(view.PlanKey),
		Status:         view.Status,
		Usage:          metricMapToStrings(view.Usage),
		Limits:         metricMapToStrings(view.Limits),
		OverLimit:      view.OverLimit,
	}
}

// ToWorkspaceUsageView converts a store workspace usage view to its API DTO shape.
func ToWorkspaceUsageView(view plan.WorkspaceUsageView) dto.WorkspaceUsageView {
	return dto.WorkspaceUsageView{
		MachineCount: view.MachineCount,
		AgentCount:   view.AgentCount,
		ChannelCount: view.ChannelCount,
		Organization: ToOrganizationPlanView(view.Organization),
	}
}

// ToAdminDBPoolResponse converts one runtime DB pool snapshot into its wire shape.
func ToAdminDBPoolResponse(snapshot coredb.DBPoolSnapshot) dto.AdminDBPoolResponse {
	return dto.AdminDBPoolResponse{
		Config: dto.AdminDBPoolConfig{
			MaxOpenConns:    snapshot.Config.MaxOpenConns,
			MaxIdleConns:    snapshot.Config.MaxIdleConns,
			ConnMaxLifetime: snapshot.Config.ConnMaxLifetime.String(),
			ConnMaxIdleTime: snapshot.Config.ConnMaxIdleTime.String(),
		},
		Stats: dto.AdminDBPoolStats{
			MaxOpenConnections: snapshot.Stats.MaxOpenConnections,
			OpenConnections:    snapshot.Stats.OpenConnections,
			InUse:              snapshot.Stats.InUse,
			Idle:               snapshot.Stats.Idle,
			WaitCount:          snapshot.Stats.WaitCount,
			WaitDuration:       snapshot.Stats.WaitDuration.String(),
			MaxIdleClosed:      snapshot.Stats.MaxIdleClosed,
			MaxIdleTimeClosed:  snapshot.Stats.MaxIdleTimeClosed,
			MaxLifetimeClosed:  snapshot.Stats.MaxLifetimeClosed,
		},
	}
}