package converter

import (
	"github.com/tidbcloud/AgentTeam/internal/api/dto"
	"github.com/tidbcloud/AgentTeam/internal/store/organization"
)

// --- Provider ---

func ToOrgProviderModel(v organization.OrganizationProviderModel) dto.OrgProviderModel {
	return dto.OrgProviderModel{Name: v.Name, ID: v.ID}
}

func ToOrgProviderModels(items []organization.OrganizationProviderModel) []dto.OrgProviderModel {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgProviderModel, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgProviderModel(item))
	}
	return out
}

func ToOrgProviderView(v organization.OrganizationProviderView) dto.OrgProviderView {
	return dto.OrgProviderView{
		ID:             v.ID,
		OrganizationID: v.OrganizationID,
		Name:           v.Name,
		Description:    v.Description,
		DriverKind:     v.DriverKind,
		ProviderType:   v.ProviderType,
		BaseURL:        v.BaseURL,
		Endpoints:      ToOrgProviderEndpoints(v.Endpoints),
		Capabilities:   ToOrgProviderCapabilities(v.Capabilities),
		Models:         ToOrgProviderModels(v.Models),
		Status:         v.Status,
		CreatedAt:      v.CreatedAt,
		UpdatedAt:      v.UpdatedAt,
	}
}

func ToOrgProviderViews(items []organization.OrganizationProviderView) []dto.OrgProviderView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgProviderView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgProviderView(item))
	}
	return out
}

func ToOrgProviderEndpoints(v organization.OrganizationProviderEndpoints) dto.OrgProviderEndpoints {
	return dto.OrgProviderEndpoints{
		MessagesBaseURL:   v.MessagesBaseURL,
		ResponsesBaseURL:  v.ResponsesBaseURL,
		EmbeddingsBaseURL: v.EmbeddingsBaseURL,
	}
}

func ToOrgProviderCapabilities(v organization.OrganizationProviderCapabilities) dto.OrgProviderCapabilities {
	return dto.OrgProviderCapabilities{
		OpenAICompatible:    v.OpenAICompatible,
		AnthropicCompatible: v.AnthropicCompatible,
		ResponsesCompatible: v.ResponsesCompatible,
		EmbeddingCompatible: v.EmbeddingCompatible,
	}
}

// --- Token ---

func ToOrgProviderTokenConfig(v organization.OrganizationProviderTokenConfig) dto.OrgProviderTokenConfig {
	return dto.OrgProviderTokenConfig{
		Role:                v.Role,
		BaseURL:             v.BaseURL,
		Mode:                v.Mode,
		BackendName:         v.BackendName,
		BackendID:           v.BackendID,
		Active:              v.Active,
		Weight:              v.Weight,
		WeightDiffThreshold: v.WeightDiffThreshold,
		AdaptiveWeights:     v.AdaptiveWeights,
		RequiresOAuthBeta:   v.RequiresOAuthBeta,
		AllowedAPIKeys:      v.AllowedAPIKeys,
		CustomPrompt:        v.CustomPrompt,
		CustomPromptModels:  v.CustomPromptModels,
	}
}

func ToOrgProviderTokenView(v organization.OrganizationProviderTokenView) dto.OrgProviderTokenView {
	return dto.OrgProviderTokenView{
		ID:                     v.ID,
		OrganizationID:         v.OrganizationID,
		OrganizationProviderID: v.OrganizationProviderID,
		Label:                  v.Label,
		TokenHint:              v.TokenHint,
		Config:                 ToOrgProviderTokenConfig(v.Config),
		Status:                 v.Status,
		LastUsedAt:             v.LastUsedAt,
		LastErrorAt:            v.LastErrorAt,
		LastErrorCode:          v.LastErrorCode,
		CreatedAt:              v.CreatedAt,
		UpdatedAt:              v.UpdatedAt,
	}
}

func ToOrgProviderTokenViews(items []organization.OrganizationProviderTokenView) []dto.OrgProviderTokenView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgProviderTokenView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgProviderTokenView(item))
	}
	return out
}

// --- Route ---

func ToOrgProviderRouteView(v organization.OrganizationProviderRouteView) dto.OrgProviderRouteView {
	return dto.OrgProviderRouteView{
		ID:             v.ID,
		OrganizationID: v.OrganizationID,
		Vendor:         v.Vendor,
		DisplayName:    v.DisplayName,
		Models:         ToOrgProviderModels(v.Models),
		SourceKind:     v.SourceKind,
		Status:         v.Status,
		CreatedAt:      v.CreatedAt,
		UpdatedAt:      v.UpdatedAt,
	}
}

func ToOrgProviderRouteViews(items []organization.OrganizationProviderRouteView) []dto.OrgProviderRouteView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgProviderRouteView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgProviderRouteView(item))
	}
	return out
}

func ToOrgProviderRouteGroupView(v organization.OrganizationProviderRouteGroupView) dto.OrgProviderRouteGroupView {
	return dto.OrgProviderRouteGroupView{
		ID:              v.ID,
		OrganizationID:  v.OrganizationID,
		RouteID:         v.RouteID,
		Models:          v.Models,
		ProviderRefs:    v.ProviderRefs,
		Strategy:        v.Strategy,
		Priority:        v.Priority,
		ManagedBySystem: v.ManagedBySystem,
		Status:          v.Status,
		CreatedAt:       v.CreatedAt,
		UpdatedAt:       v.UpdatedAt,
	}
}

func ToOrgProviderRouteGroupViews(items []organization.OrganizationProviderRouteGroupView) []dto.OrgProviderRouteGroupView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgProviderRouteGroupView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgProviderRouteGroupView(item))
	}
	return out
}

// --- Workspace Grants ---

func ToOrgWorkspaceProviderGrantView(v organization.OrganizationWorkspaceProviderGrantView) dto.OrgWorkspaceProviderGrantView {
	return dto.OrgWorkspaceProviderGrantView{
		WorkspaceID:   v.WorkspaceID,
		ProviderID:    v.ProviderID,
		ProviderName:  v.ProviderName,
		DriverKind:    v.DriverKind,
		ProviderType:  v.ProviderType,
		BaseURL:       v.BaseURL,
		Models:        ToOrgProviderModels(v.Models),
		Status:        v.Status,
		GrantedAt:     v.GrantedAt,
		LastUpdatedAt: v.LastUpdatedAt,
	}
}

func ToOrgWorkspaceProviderGrantViews(items []organization.OrganizationWorkspaceProviderGrantView) []dto.OrgWorkspaceProviderGrantView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgWorkspaceProviderGrantView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgWorkspaceProviderGrantView(item))
	}
	return out
}

func ToOrgWorkspaceRouteGrantView(v organization.OrganizationWorkspaceRouteGrantView) dto.OrgWorkspaceRouteGrantView {
	return dto.OrgWorkspaceRouteGrantView{
		WorkspaceID:   v.WorkspaceID,
		RouteID:       v.RouteID,
		Vendor:        v.Vendor,
		DisplayName:   v.DisplayName,
		Models:        ToOrgProviderModels(v.Models),
		Status:        v.Status,
		GrantedAt:     v.GrantedAt,
		LastUpdatedAt: v.LastUpdatedAt,
	}
}

func ToOrgWorkspaceRouteGrantViews(items []organization.OrganizationWorkspaceRouteGrantView) []dto.OrgWorkspaceRouteGrantView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgWorkspaceRouteGrantView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgWorkspaceRouteGrantView(item))
	}
	return out
}

// --- Hosted Models ---

func ToOrgHostedModelSettingsView(v organization.OrganizationHostedModelSettingsView) dto.OrganizationHostedModelSettingsView {
	return dto.OrganizationHostedModelSettingsView{
		OrganizationID:             v.OrganizationID,
		PickerVisibilityPolicy:     v.PickerVisibilityPolicy,
		AutoAuthorizationEnabled:   v.AutoAuthorizationEnabled,
		AutoAuthorizationMode:      v.AutoAuthorizationMode,
		AutoAuthorizationModelRefs: v.AutoAuthorizationModelRefs,
		UpdatedAt:                  v.UpdatedAt,
	}
}

func ToOrgWorkspaceHostedModelAuthorizationView(v organization.OrganizationWorkspaceHostedModelAuthorizationView) dto.OrganizationWorkspaceHostedModelAuthorizationView {
	return dto.OrganizationWorkspaceHostedModelAuthorizationView{
		OrganizationID:           v.OrganizationID,
		WorkspaceID:              v.WorkspaceID,
		AuthorizationMode:        v.AuthorizationMode,
		SelectedModelRefs:        v.SelectedModelRefs,
		Status:                   v.Status,
		Configured:               v.Configured,
		AuthorizedByUserID:       v.AuthorizedByUserID,
		AffectedHostedAgentCount: v.AffectedHostedAgentCount,
		CreatedAt:                v.CreatedAt,
		UpdatedAt:                v.UpdatedAt,
	}
}

// --- LLM Proxy Keys ---

func ToOrgLLMProxyKeyView(v organization.OrganizationLLMProxyKeyView) dto.OrgLLMProxyKeyView {
	return dto.OrgLLMProxyKeyView{
		ID:             v.ID,
		OrganizationID: v.OrganizationID,
		Label:          v.Label,
		TokenHint:      v.TokenHint,
		Status:         v.Status,
		LastUsedAt:     v.LastUsedAt,
		LastErrorAt:    v.LastErrorAt,
		LastErrorCode:  v.LastErrorCode,
		CreatedAt:      v.CreatedAt,
		UpdatedAt:      v.UpdatedAt,
	}
}

func ToOrgLLMProxyKeyViews(items []organization.OrganizationLLMProxyKeyView) []dto.OrgLLMProxyKeyView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgLLMProxyKeyView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgLLMProxyKeyView(item))
	}
	return out
}

func ToOrgLLMProxyKeyCreateResult(v organization.OrganizationLLMProxyKeyCreateResult) dto.OrgLLMProxyKeyCreateResult {
	return dto.OrgLLMProxyKeyCreateResult{
		Key:   ToOrgLLMProxyKeyView(v.Key),
		Token: v.Token,
	}
}

// --- LLM Stats ---

func ToOrgLLMStatsSummaryView(v organization.OrganizationLLMStatsSummaryView) dto.OrgLLMStatsSummaryView {
	return dto.OrgLLMStatsSummaryView(v)
}

func ToOrgLLMStatsSummaryViews(items []organization.OrganizationLLMStatsSummaryView) []dto.OrgLLMStatsSummaryView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgLLMStatsSummaryView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgLLMStatsSummaryView(item))
	}
	return out
}

func ToOrgLLMModelStatView(v organization.OrganizationLLMModelStatView) dto.OrgLLMModelStatView {
	return dto.OrgLLMModelStatView(v)
}

func ToOrgLLMStatsDetailView(v organization.OrganizationLLMStatsDetailView) dto.OrgLLMStatsDetailView {
	return dto.OrgLLMStatsDetailView{
		SubjectType: v.SubjectType,
		SubjectID:   v.SubjectID,
		SubjectName: v.SubjectName,
		Source:      v.Source,
		Models:      ToOrgLLMModelStatViews(v.Models),
	}
}

func ToOrgLLMStatsDetailViews(items []organization.OrganizationLLMStatsDetailView) []dto.OrgLLMStatsDetailView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgLLMStatsDetailView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgLLMStatsDetailView(item))
	}
	return out
}

func ToOrgLLMModelStatViews(items []organization.OrganizationLLMModelStatView) []dto.OrgLLMModelStatView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgLLMModelStatView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgLLMModelStatView(item))
	}
	return out
}

func ToOrgLLMTimeSeriesView(v organization.OrganizationLLMTimeSeriesView) dto.OrgLLMTimeSeriesView {
	return dto.OrgLLMTimeSeriesView{
		Interval: v.Interval,
		Data:     ToOrgLLMTimeSeriesPoints(v.Data),
	}
}

func ToOrgLLMTimeSeriesPoints(items []organization.OrganizationLLMTimeSeriesPoint) []dto.OrgLLMTimeSeriesPoint {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgLLMTimeSeriesPoint, 0, len(items))
	for _, item := range items {
		out = append(out, dto.OrgLLMTimeSeriesPoint(item))
	}
	return out
}

func ToOrgLLMErrorSummaryView(v organization.OrganizationLLMErrorSummaryView) dto.OrgLLMErrorSummaryView {
	return dto.OrgLLMErrorSummaryView{
		LastErrorTime:   v.LastErrorTime,
		Total1h:         v.Total1h,
		Total6h:         v.Total6h,
		Total12h:        v.Total12h,
		Total24h:        v.Total24h,
		Total1w:         v.Total1w,
		RequestCount1h:  v.RequestCount1h,
		RequestCount6h:  v.RequestCount6h,
		RequestCount12h: v.RequestCount12h,
		RequestCount24h: v.RequestCount24h,
		RequestCount1w:  v.RequestCount1w,
		ErrorTypes:      ToOrgLLMErrorTypeStatsViews(v.ErrorTypes),
	}
}

func ToOrgLLMErrorTypeStatsViews(items []organization.OrganizationLLMErrorTypeStatsView) []dto.OrgLLMErrorTypeStatsView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgLLMErrorTypeStatsView, 0, len(items))
	for _, item := range items {
		out = append(out, dto.OrgLLMErrorTypeStatsView(item))
	}
	return out
}

func ToOrgLLMErrorTimeSeriesView(v organization.OrganizationLLMErrorTimeSeriesView) dto.OrgLLMErrorTimeSeriesView {
	return dto.OrgLLMErrorTimeSeriesView{
		Interval: v.Interval,
		Data:     ToOrgLLMErrorTimeSeriesPoints(v.Data),
	}
}

func ToOrgLLMErrorTimeSeriesPoints(items []organization.OrganizationLLMErrorTimeSeriesPoint) []dto.OrgLLMErrorTimeSeriesPoint {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgLLMErrorTimeSeriesPoint, 0, len(items))
	for _, item := range items {
		out = append(out, dto.OrgLLMErrorTimeSeriesPoint(item))
	}
	return out
}

func ToOrgLLMQuotaPolicyView(v organization.OrganizationLLMQuotaPolicyView) dto.OrgLLMQuotaPolicyView {
	return dto.OrgLLMQuotaPolicyView(v)
}

func ToOrgLLMQuotaPolicyViews(items []organization.OrganizationLLMQuotaPolicyView) []dto.OrgLLMQuotaPolicyView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrgLLMQuotaPolicyView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgLLMQuotaPolicyView(item))
	}
	return out
}

// --- Enterprise Feishu ---

func ToOrgEnterpriseFeishuView(v organization.OrganizationEnterpriseFeishuView) dto.OrganizationEnterpriseFeishuView {
	return dto.OrganizationEnterpriseFeishuView{
		OrganizationID:                v.OrganizationID,
		StorageReady:                  v.StorageReady,
		CredentialsConfigured:         v.CredentialsConfigured,
		CredentialSource:              v.CredentialSource,
		UpdatedAt:                     v.UpdatedAt,
		LastValidatedAt:               v.LastValidatedAt,
		AvailableRootDepartments:      ToOrgFeishuDepartmentOptionViews(v.AvailableRootDepartments),
		AvailableRootDepartmentsError: v.AvailableRootDepartmentsError,
	}
}

func ToOrgFeishuDepartmentOptionViews(items []organization.OrganizationFeishuDepartmentOptionView) []dto.OrganizationFeishuDepartmentOptionView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationFeishuDepartmentOptionView, 0, len(items))
	for _, item := range items {
		out = append(out, dto.OrganizationFeishuDepartmentOptionView{
			DepartmentID: item.DepartmentID,
			Name:         item.Name,
		})
	}
	return out
}

func ToOrgFeishuDirectoryImportResult(v organization.OrganizationFeishuDirectoryImportResult) dto.OrganizationFeishuDirectoryImportResult {
	return dto.OrganizationFeishuDirectoryImportResult{
		SyncRunID:               v.SyncRunID,
		ImportedUnitCount:       v.ImportedUnitCount,
		ImportedMemberCount:     v.ImportedMemberCount,
		ImportedMembershipCount: v.ImportedMembershipCount,
	}
}

// --- Organization Summary ---

func ToOrgSummary(v organization.OrganizationSummary) dto.OrganizationSummary {
	return dto.OrganizationSummary{
		ID:            v.ID,
		Slug:          v.Slug,
		Name:          v.Name,
		Role:          v.Role,
		DefaultTeamID: v.DefaultTeamID,
	}
}

func ToOrgSummaries(items []organization.OrganizationSummary) []dto.OrganizationSummary {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationSummary, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgSummary(item))
	}
	return out
}

// --- Settings ---

func ToOrgFeishuAutoJoinStatusView(v *organization.OrganizationFeishuAutoJoinStatusView) *dto.OrganizationFeishuAutoJoinStatusView {
	if v == nil {
		return nil
	}
	return &dto.OrganizationFeishuAutoJoinStatusView{
		Status:      v.Status,
		SubjectType: v.SubjectType,
		SubjectHint: v.SubjectHint,
		Message:     v.Message,
		AttemptedAt: v.AttemptedAt,
	}
}

func ToOrgDirectorySyncRunSummaryView(v *organization.OrganizationDirectorySyncRunSummaryView) *dto.OrganizationDirectorySyncRunSummaryView {
	if v == nil {
		return nil
	}
	return &dto.OrganizationDirectorySyncRunSummaryView{
		SyncRunID:         v.SyncRunID,
		ExternalProvider:  v.ExternalProvider,
		SyncSource:        v.SyncSource,
		Status:            v.Status,
		DirectoryRevision: v.DirectoryRevision,
		StartedAt:         v.StartedAt,
		CompletedAt:       v.CompletedAt,
	}
}

func ToOrgFeishuProviderSettingsView(v organization.OrganizationFeishuProviderSettingsView) dto.OrganizationFeishuProviderSettingsView {
	return dto.OrganizationFeishuProviderSettingsView{
		TenantKey:        v.TenantKey,
		RootDepartmentID: v.RootDepartmentID,
		HasServerConfig:  v.HasServerConfig,
		LastSync:         ToOrgDirectorySyncRunSummaryView(v.LastSync),
		LastAutoJoin:     ToOrgFeishuAutoJoinStatusView(v.LastAutoJoin),
	}
}

func ToOrgSettingsView(v organization.OrganizationSettingsView) dto.OrganizationSettingsView {
	return dto.OrganizationSettingsView{
		OrganizationID:    v.OrganizationID,
		DirectoryBackend:  v.DirectoryBackend,
		DirectoryRevision: v.DirectoryRevision,
		AuthProvider:      v.AuthProvider,
		DirectoryProvider: v.DirectoryProvider,
		Feishu:            ToOrgFeishuProviderSettingsView(v.Feishu),
	}
}

func ToOrgDirectorySyncRunDetailView(v organization.OrganizationDirectorySyncRunDetailView) dto.OrganizationDirectorySyncRunDetailView {
	return dto.OrganizationDirectorySyncRunDetailView{
		SyncRunID:         v.SyncRunID,
		ExternalProvider:  v.ExternalProvider,
		SyncSource:        v.SyncSource,
		Status:            v.Status,
		DirectoryRevision: v.DirectoryRevision,
		StartedAt:         v.StartedAt,
		CompletedAt:       v.CompletedAt,
		LinkedTeamCount:   v.LinkedTeamCount,
		LinkedUnitCount:   v.LinkedUnitCount,
		LinkedMemberCount: v.LinkedMemberCount,
	}
}

// --- Invite ---

func ToOrgInviteView(v organization.OrganizationInviteView) dto.OrganizationInviteView {
	return dto.OrganizationInviteView{
		ID:                   v.ID,
		Email:                v.Email,
		Role:                 v.Role,
		TeamID:               v.TeamID,
		TeamName:             v.TeamName,
		DefaultWorkspaceRole: v.DefaultWorkspaceRole,
		CreatedAt:            v.CreatedAt,
		ExpiresAt:            v.ExpiresAt,
	}
}

func ToOrgInviteViews(items []organization.OrganizationInviteView) []dto.OrganizationInviteView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationInviteView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgInviteView(item))
	}
	return out
}

func ToOrgInvitePageResponse(page organization.OrganizationInvitePage) dto.OrganizationInvitePageResponse {
	return dto.OrganizationInvitePageResponse{
		Invites:    ToOrgInviteViews(page.Invites),
		HasMore:    page.HasMore,
		NextCursor: page.NextCursor,
	}
}

// --- Unit ---

func ToOrgSyncMetadata(v organization.OrganizationSyncMetadata) dto.OrganizationSyncMetadata {
	return dto.OrganizationSyncMetadata{
		ExternalProvider:          v.ExternalProvider,
		ExternalID:                v.ExternalID,
		SyncedAt:                  v.SyncedAt,
		SyncMode:                  v.SyncMode,
		SyncSource:                v.SyncSource,
		LastSyncRunID:             v.LastSyncRunID,
		LastSyncDirectoryRevision: v.LastSyncDirectoryRevision,
		LastSyncRunStatus:         v.LastSyncRunStatus,
		ReadOnly:                  v.ReadOnly,
	}
}

func ToOrgUnitView(v organization.OrganizationUnitView) dto.OrganizationUnitView {
	return dto.OrganizationUnitView{
		ID:                       v.ID,
		ParentUnitID:             v.ParentUnitID,
		ManagerMemberID:          v.ManagerMemberID,
		Name:                     v.Name,
		Slug:                     v.Slug,
		Status:                   v.Status,
		IsDefault:                v.IsDefault,
		MemberCount:              v.MemberCount,
		OrganizationSyncMetadata: ToOrgSyncMetadata(v.OrganizationSyncMetadata),
	}
}

func ToOrgUnitViews(items []organization.OrganizationUnitView) []dto.OrganizationUnitView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationUnitView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgUnitView(item))
	}
	return out
}

func ToOrgUnitMemberView(v organization.OrganizationUnitMemberView) dto.OrganizationUnitMemberView {
	return dto.OrganizationUnitMemberView{
		UnitID:          v.UnitID,
		MemberID:        v.MemberID,
		UserID:          v.UserID,
		Email:           v.Email,
		Name:            v.Name,
		DisplayName:     v.DisplayName,
		Source:          v.Source,
		Status:          v.Status,
		IsPrimary:       v.IsPrimary,
		PrimaryUnitID:   v.PrimaryUnitID,
		PrimaryUnitName: v.PrimaryUnitName,
	}
}

func ToOrgUnitMemberViews(items []organization.OrganizationUnitMemberView) []dto.OrganizationUnitMemberView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationUnitMemberView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgUnitMemberView(item))
	}
	return out
}

// --- Team ---

func ToOrgTeamView(v organization.OrganizationTeamView) dto.OrganizationTeamView {
	return dto.OrganizationTeamView{
		ID:                       v.ID,
		Name:                     v.Name,
		Slug:                     v.Slug,
		Description:              v.Description,
		Status:                   v.Status,
		Source:                   v.Source,
		IsDefault:                v.IsDefault,
		OrganizationSyncMetadata: ToOrgSyncMetadata(v.OrganizationSyncMetadata),
	}
}

func ToOrgTeamViews(items []organization.OrganizationTeamView) []dto.OrganizationTeamView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationTeamView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgTeamView(item))
	}
	return out
}

func ToOrgTeamMemberView(v organization.OrganizationTeamMemberView) dto.OrganizationTeamMemberView {
	return dto.OrganizationTeamMemberView{
		TeamID:          v.TeamID,
		MemberID:        v.MemberID,
		UserID:          v.UserID,
		Email:           v.Email,
		Name:            v.Name,
		DisplayName:     v.DisplayName,
		MembershipRole:  v.MembershipRole,
		Source:          v.Source,
		Status:          v.Status,
		IsPrimary:       v.IsPrimary,
		PrimaryTeamID:   v.PrimaryTeamID,
		PrimaryTeamName: v.PrimaryTeamName,
	}
}

func ToOrgTeamMemberViews(items []organization.OrganizationTeamMemberView) []dto.OrganizationTeamMemberView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationTeamMemberView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgTeamMemberView(item))
	}
	return out
}

// --- Account ---

func ToOrgMemberWorkspaceAccessView(v organization.OrganizationMemberWorkspaceAccessView) dto.OrganizationMemberWorkspaceAccessView {
	return dto.OrganizationMemberWorkspaceAccessView{
		WorkspaceID:   v.WorkspaceID,
		WorkspaceName: v.WorkspaceName,
		WorkspaceSlug: v.WorkspaceSlug,
		Role:          v.Role,
		Sources:       v.Sources,
	}
}

func ToOrgMemberView(v organization.OrganizationMemberView) dto.OrganizationMemberView {
	accesses := make([]dto.OrganizationMemberWorkspaceAccessView, 0, len(v.WorkspaceAccesses))
	for _, a := range v.WorkspaceAccesses {
		accesses = append(accesses, ToOrgMemberWorkspaceAccessView(a))
	}
	return dto.OrganizationMemberView{
		ID:                       v.ID,
		UserID:                   v.UserID,
		Email:                    v.Email,
		Name:                     v.Name,
		DisplayName:              v.DisplayName,
		PrimaryTeamID:            v.PrimaryTeamID,
		PrimaryTeamName:          v.PrimaryTeamName,
		Status:                   v.Status,
		Role:                     v.Role,
		Source:                   v.Source,
		DefaultWorkspaceRole:     v.DefaultWorkspaceRole,
		WorkspaceAccessCount:     v.WorkspaceAccessCount,
		WorkspaceAccesses:        accesses,
		OrganizationSyncMetadata: ToOrgSyncMetadata(v.OrganizationSyncMetadata),
	}
}

func ToOrgMemberViews(items []organization.OrganizationMemberView) []dto.OrganizationMemberView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationMemberView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgMemberView(item))
	}
	return out
}

func ToOrgMemberPageResponse(page organization.OrganizationMemberPage) dto.OrganizationMemberPageResponse {
	return dto.OrganizationMemberPageResponse{
		Members:    ToOrgMemberViews(page.Members),
		HasMore:    page.HasMore,
		NextCursor: page.NextCursor,
	}
}

func ToOrgMemberRemovalImpact(v organization.OrganizationMemberRemovalImpact) dto.OrganizationMemberRemovalImpactResponse {
	return dto.OrganizationMemberRemovalImpactResponse{
		Member:             ToOrgMemberView(v.Member),
		BlockingReasons:    ToOrgMemberRemovalBlockers(v.BlockingReasons),
		AffectedWorkspaces: ToOrgMemberRemovalWorkspaces(v.AffectedWorkspaces),
		AgentsToDisable:    ToOrgMemberRemovalAgents(v.AgentsToDisable),
		MachinesToRevoke:   ToOrgMemberRemovalMachines(v.MachinesToRevoke),
	}
}

func ToOrgMemberRemovalBlocker(v organization.OrganizationMemberRemovalBlocker) dto.OrganizationMemberRemovalBlockerResponse {
	return dto.OrganizationMemberRemovalBlockerResponse{
		Code:          v.Code,
		Message:       v.Message,
		WorkspaceID:   v.WorkspaceID,
		WorkspaceName: v.WorkspaceName,
	}
}

func ToOrgMemberRemovalBlockers(items []organization.OrganizationMemberRemovalBlocker) []dto.OrganizationMemberRemovalBlockerResponse {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationMemberRemovalBlockerResponse, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgMemberRemovalBlocker(item))
	}
	return out
}

func ToOrgMemberRemovalWorkspace(v organization.OrganizationMemberRemovalWorkspace) dto.OrganizationMemberRemovalWorkspaceResponse {
	return dto.OrganizationMemberRemovalWorkspaceResponse{
		ID:      v.ID,
		Name:    v.Name,
		Slug:    v.Slug,
		Role:    v.Role,
		Sources: v.Sources,
	}
}

func ToOrgMemberRemovalWorkspaces(items []organization.OrganizationMemberRemovalWorkspace) []dto.OrganizationMemberRemovalWorkspaceResponse {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationMemberRemovalWorkspaceResponse, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgMemberRemovalWorkspace(item))
	}
	return out
}

func ToOrgMemberRemovalAgent(v organization.OrganizationMemberRemovalAgent) dto.OrganizationMemberRemovalAgentResponse {
	return dto.OrganizationMemberRemovalAgentResponse{
		ID:          v.ID,
		Name:        v.Name,
		WorkspaceID: v.WorkspaceID,
	}
}

func ToOrgMemberRemovalAgents(items []organization.OrganizationMemberRemovalAgent) []dto.OrganizationMemberRemovalAgentResponse {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationMemberRemovalAgentResponse, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgMemberRemovalAgent(item))
	}
	return out
}

func ToOrgMemberRemovalMachine(v organization.OrganizationMemberRemovalMachine) dto.OrganizationMemberRemovalMachineResponse {
	return dto.OrganizationMemberRemovalMachineResponse{
		ID:          v.ID,
		Name:        v.Name,
		WorkspaceID: v.WorkspaceID,
	}
}

func ToOrgMemberRemovalMachines(items []organization.OrganizationMemberRemovalMachine) []dto.OrganizationMemberRemovalMachineResponse {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationMemberRemovalMachineResponse, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgMemberRemovalMachine(item))
	}
	return out
}

func ToOrgMemberRemovalResult(v organization.OrganizationMemberRemovalResult) dto.OrganizationMemberRemovalResultResponse {
	return dto.OrganizationMemberRemovalResultResponse{
		MemberID:   v.MemberID,
		Status:     v.Status,
		DisabledAt: v.DisabledAt,
	}
}

func ToOrgMemberUnitView(v organization.OrganizationMemberUnitView) dto.OrganizationMemberUnitView {
	return dto.OrganizationMemberUnitView{
		MemberID:     v.MemberID,
		UnitID:       v.UnitID,
		UnitName:     v.UnitName,
		UnitSlug:     v.UnitSlug,
		ParentUnitID: v.ParentUnitID,
		Source:       v.Source,
		Status:       v.Status,
		IsPrimary:    v.IsPrimary,
	}
}

func ToOrgMemberUnitViews(items []organization.OrganizationMemberUnitView) []dto.OrganizationMemberUnitView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationMemberUnitView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgMemberUnitView(item))
	}
	return out
}

// --- Workspace ---

func ToOrgWorkspaceView(v organization.OrganizationWorkspaceView) dto.OrganizationWorkspaceView {
	return dto.OrganizationWorkspaceView{
		ID:               v.ID,
		Slug:             v.Slug,
		Name:             v.Name,
		BoundAt:          v.BoundAt,
		IsDefault:        v.IsDefault,
		HumanMemberCount: v.HumanMemberCount,
		AgentCount:       v.AgentCount,
	}
}

func ToOrgWorkspaceViews(items []organization.OrganizationWorkspaceView) []dto.OrganizationWorkspaceView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationWorkspaceView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgWorkspaceView(item))
	}
	return out
}

func ToOrgWorkspaceGrantView(v organization.OrganizationWorkspaceGrantView) dto.OrganizationWorkspaceGrantView {
	return dto.OrganizationWorkspaceGrantView{
		WorkspaceID:       v.WorkspaceID,
		MemberID:          v.MemberID,
		UserID:            v.UserID,
		WorkspaceMemberID: v.WorkspaceMemberID,
		Role:              v.Role,
		Source:            v.Source,
	}
}

func ToOrgWorkspaceGrantViews(items []organization.OrganizationWorkspaceGrantView) []dto.OrganizationWorkspaceGrantView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationWorkspaceGrantView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgWorkspaceGrantView(item))
	}
	return out
}

func ToOrgWorkspaceTeamGrantView(v organization.OrganizationWorkspaceTeamGrantView) dto.OrganizationWorkspaceTeamGrantView {
	return dto.OrganizationWorkspaceTeamGrantView{
		WorkspaceID: v.WorkspaceID,
		TeamID:      v.TeamID,
		TeamName:    v.TeamName,
		Role:        v.Role,
		Source:      v.Source,
		Status:      v.Status,
		MemberCount: v.MemberCount,
	}
}

func ToOrgWorkspaceTeamGrantViews(items []organization.OrganizationWorkspaceTeamGrantView) []dto.OrganizationWorkspaceTeamGrantView {
	if items == nil {
		return nil
	}
	out := make([]dto.OrganizationWorkspaceTeamGrantView, 0, len(items))
	for _, item := range items {
		out = append(out, ToOrgWorkspaceTeamGrantView(item))
	}
	return out
}