package threads_account

import (
	pqdomain "haixun-backend/internal/model/publish_queue/domain/usecase"
	domusecase "haixun-backend/internal/model/threads_account/domain/usecase"
	"haixun-backend/internal/types"
)

func toThreadsAccountData(item domusecase.AccountSummary) types.ThreadsAccountData {
	return types.ThreadsAccountData{
		ID:                item.ID,
		DisplayName:       item.DisplayName,
		Username:          item.Username,
		ThreadsUserID:     item.ThreadsUserID,
		PersonaID:         item.PersonaID,
		BrowserConnected:  item.BrowserConnected,
		ApiConnected:      item.ApiConnected,
		APITokenExpiresAt: item.APITokenExpiresAt,
		Status:            item.Status,
		CreateAt:          item.CreateAt,
		UpdateAt:          item.UpdateAt,
	}
}

func toPostPerformanceData(result *domusecase.PostPerformanceResult) *types.ThreadsPostPerformanceData {
	if result == nil {
		return &types.ThreadsPostPerformanceData{Posts: []types.ThreadsPostPerformanceItem{}}
	}
	caps := make([]types.ThreadsPostMetricCapability, 0, len(result.Capabilities))
	for _, item := range result.Capabilities {
		caps = append(caps, types.ThreadsPostMetricCapability{
			Scope: item.Scope, Name: item.Name, Metrics: item.Metrics,
			Trackable: item.Trackable, Note: item.Note,
		})
	}
	metrics := make([]types.ThreadsInsightMetricItem, 0, len(result.AccountInsights.Metrics))
	for _, item := range result.AccountInsights.Metrics {
		metrics = append(metrics, types.ThreadsInsightMetricItem{Name: item.Name, Value: item.Value})
	}
	posts := make([]types.ThreadsPostPerformanceItem, 0, len(result.Posts))
	for _, item := range result.Posts {
		posts = append(posts, types.ThreadsPostPerformanceItem{
			MediaID: item.MediaID, Text: item.Text, Permalink: item.Permalink, Timestamp: item.Timestamp,
			LikeCount: item.LikeCount, ReplyCount: item.ReplyCount, RepostCount: item.RepostCount, QuoteCount: item.QuoteCount,
			Views: item.Views, Shares: item.Shares, InsightsStatus: item.InsightsStatus, InsightsMessage: item.InsightsMessage,
		})
	}
	return &types.ThreadsPostPerformanceData{
		AccountID: result.AccountID, Username: result.Username, ThreadsUserID: result.ThreadsUserID,
		FetchedAt: result.FetchedAt, Capabilities: caps,
		AccountInsights: types.ThreadsAccountInsightsBlock{
			Status: result.AccountInsights.Status, Message: result.AccountInsights.Message, Metrics: metrics,
		},
		Posts: posts,
	}
}

func toListData(result *domusecase.ListResult) *types.ListThreadsAccountsData {
	if result == nil {
		return &types.ListThreadsAccountsData{List: []types.ThreadsAccountData{}}
	}
	list := make([]types.ThreadsAccountData, 0, len(result.List))
	for _, item := range result.List {
		list = append(list, toThreadsAccountData(item))
	}
	return &types.ListThreadsAccountsData{
		List:            list,
		ActiveAccountID: result.ActiveAccountID,
	}
}

func toConnectionData(data *domusecase.ConnectionData) *types.ThreadsAccountConnectionData {
	if data == nil {
		return nil
	}
	return &types.ThreadsAccountConnectionData{
		AccountID:        data.AccountID,
		AccountName:      data.AccountName,
		Username:         data.Username,
		BrowserConnected: data.BrowserConnected,
		ApiConnected:     data.ApiConnected,
		Prefs: types.ThreadsAccountConnectionPrefs{
			SearchViaApi:     data.Prefs.SearchViaApi,
			SearchSourceMode: data.Prefs.SearchSourceMode,
			PublishViaApi:    data.Prefs.PublishViaApi,
			DevMode:          data.Prefs.DevMode,
			ScrapeReplies:    data.Prefs.ScrapeReplies,
			RepliesPerPost:   data.Prefs.RepliesPerPost,
			PublishHeaded:    data.Prefs.PublishHeaded,
			PlaywrightDebug:  data.Prefs.PlaywrightDebug,
		},
	}
}

func toPublishQueueItemData(item *pqdomain.QueueItemSummary) *types.PublishQueueItemData {
	if item == nil {
		return nil
	}
	return &types.PublishQueueItemData{
		ID:           item.ID,
		AccountID:    item.AccountID,
		Text:         item.Text,
		ScheduledAt:  item.ScheduledAt,
		Status:       item.Status,
		MediaID:      item.MediaID,
		Permalink:    item.Permalink,
		PublishedAt:  item.PublishedAt,
		ErrorMessage: item.ErrorMessage,
		CreateAt:     item.CreateAt,
		UpdateAt:     item.UpdateAt,
	}
}

func toPublishQueueListData(result *pqdomain.ListResult) *types.PublishQueueListData {
	if result == nil {
		return &types.PublishQueueListData{List: []types.PublishQueueItemData{}}
	}
	list := make([]types.PublishQueueItemData, 0, len(result.Items))
	for _, item := range result.Items {
		if data := toPublishQueueItemData(&item); data != nil {
			list = append(list, *data)
		}
	}
	return &types.PublishQueueListData{
		Pagination: types.PaginationData{
			Total:      result.Total,
			Page:       int64(result.Page),
			PageSize:   int64(result.PageSize),
			TotalPages: int64(result.TotalPages),
		},
		List: list,
	}
}

func toPublishHealthData(result *pqdomain.PublishHealthResult) *types.ThreadsPublishHealthData {
	if result == nil {
		return &types.ThreadsPublishHealthData{List: []types.ThreadsPublishHealthItem{}}
	}
	list := make([]types.ThreadsPublishHealthItem, 0, len(result.Items))
	for _, item := range result.Items {
		cps := make([]types.ThreadsPublishHealthCheckpoint, 0, len(item.Checkpoints))
		for _, cp := range item.Checkpoints {
			cps = append(cps, types.ThreadsPublishHealthCheckpoint{
				Checkpoint: cp.Checkpoint, LikeCount: cp.LikeCount, ReplyCount: cp.ReplyCount,
				RepostCount: cp.RepostCount, QuoteCount: cp.QuoteCount, Views: cp.Views, CheckedAt: cp.CheckedAt,
			})
		}
		list = append(list, types.ThreadsPublishHealthItem{
			MediaID: item.MediaID, Permalink: item.Permalink, Text: item.Text,
			PublishedAt: item.PublishedAt, LikeCount: item.LikeCount, ReplyCount: item.ReplyCount,
			RepostCount: item.RepostCount, QuoteCount: item.QuoteCount,
			Views: item.Views, Shares: item.Shares, Checkpoints: cps,
		})
	}
	return &types.ThreadsPublishHealthData{
		Summary: types.ThreadsPublishHealthSummary{
			PendingScheduled: result.Summary.PendingScheduled,
			FailedCount:      result.Summary.FailedCount,
			Published7d:      result.Summary.Published7d,
			TotalLikes7d:     result.Summary.TotalLikes7d,
			TotalReplies7d:   result.Summary.TotalReplies7d,
		},
		Pagination: types.PaginationData{
			Total: result.Total, Page: int64(result.Page), PageSize: int64(result.PageSize), TotalPages: int64(result.TotalPages),
		},
		List: list,
	}
}

func toConnectionPatch(req *types.UpdateThreadsAccountConnectionReq) domusecase.ConnectionPrefsPatch {
	if req == nil {
		return domusecase.ConnectionPrefsPatch{}
	}
	return domusecase.ConnectionPrefsPatch{
		SearchViaApi:     req.SearchViaApi,
		SearchSourceMode: req.SearchSourceMode,
		PublishViaApi:    req.PublishViaApi,
		DevMode:          req.DevMode,
		ScrapeReplies:    req.ScrapeReplies,
		RepliesPerPost:   req.RepliesPerPost,
		PublishHeaded:    req.PublishHeaded,
		PlaywrightDebug:  req.PlaywrightDebug,
	}
}