package sv

import (
	"context"
	"fmt"
	"strings"
	"time"

	"github.com/LoveLosita/smartflow/backend/respond"
	forumdao "github.com/LoveLosita/smartflow/backend/services/taskclassforum/dao"
	forummodel "github.com/LoveLosita/smartflow/backend/services/taskclassforum/model"
	forumcontracts "github.com/LoveLosita/smartflow/backend/shared/contracts/taskclassforum"
)

// ImportPost 从论坛模板导入当前用户自己的 TaskClass 副本。
//
// 职责边界：
// 1. 同一用户同一帖子只允许导入一次，由 forum_imports 唯一约束兜底；
// 2. 只通过 TaskClassSnapshotPort 创建 TaskClass，不写 schedule；
// 3. 只写 forum_imports 和 import_count，Token 奖励后续基于 event_id 消费。
func (s *Service) ImportPost(ctx context.Context, req forumcontracts.ImportForumPostRequest) (*forumcontracts.ImportForumPostResult, error) {
	if err := s.Ready(); err != nil {
		return nil, err
	}
	if req.ActorUserID == 0 || req.PostID == 0 {
		return nil, respond.MissingParam
	}
	if strings.TrimSpace(req.TargetTitle) != "" {
		if err := validateRuneMax(req.TargetTitle, maxImportTitle); err != nil {
			return nil, err
		}
	}
	if s.taskClassPort == nil {
		return nil, ErrTaskClassPortMissing
	}

	idempotencyKey := strings.TrimSpace(req.IdempotencyKey)
	if idempotencyKey != "" {
		existing, err := s.forumDAO.FindImportByIdempotencyKey(ctx, req.ActorUserID, idempotencyKey)
		if err != nil {
			return nil, err
		}
		if existing != nil && existing.Status == forummodel.ForumImportStatusImported {
			return importResultFromModel(*existing), nil
		}
	}
	existing, err := s.forumDAO.FindImport(ctx, req.PostID, req.ActorUserID)
	if err != nil {
		return nil, err
	}
	if existing != nil && existing.Status == forummodel.ForumImportStatusImported {
		return importResultFromModel(*existing), nil
	}
	if existing != nil && existing.Status == forummodel.ForumImportStatusFailed && existing.NewTaskClassID != nil {
		return s.recoverCreatedImport(ctx, req, *existing)
	}
	if existing != nil && existing.Status == forummodel.ForumImportStatusPending {
		return nil, respond.RequestIsProcessing
	}

	post, template, items, err := s.loadPostTemplate(ctx, req.PostID)
	if err != nil {
		return nil, err
	}
	snapshot := snapshotFromTemplate(*post, *template, items)
	targetTitle := strings.TrimSpace(req.TargetTitle)
	if targetTitle == "" {
		targetTitle = post.Title
	}

	pending, err := s.reserveImport(ctx, req, post.AuthorUserID, targetTitle, idempotencyKey)
	if err != nil {
		return nil, err
	}
	if pending.Status == forummodel.ForumImportStatusImported {
		result := importResultFromModel(*pending)
		result.ImportCount = post.ImportCount
		return result, nil
	}

	created, err := s.taskClassPort.CreateTaskClassFromSnapshot(ctx, req.ActorUserID, snapshot, targetTitle)
	if err != nil {
		_ = s.forumDAO.MarkImportFailed(ctx, pending.ID, err.Error(), time.Now())
		return nil, err
	}
	if created == nil {
		err := respond.InternalError(fmt.Errorf("taskclass adapter returned nil created taskclass"))
		_ = s.forumDAO.MarkImportFailed(ctx, pending.ID, err.Info, time.Now())
		return nil, err
	}

	var imported forummodel.ForumImport
	if err := s.forumDAO.Transaction(ctx, func(txDAO *forumdao.ForumDAO) error {
		if _, err := txDAO.LockPublishedPost(ctx, req.PostID); err != nil {
			return normalizeRecordNotFound(err, respond.UserTaskClassNotFound)
		}
		again, err := txDAO.FindImport(ctx, req.PostID, req.ActorUserID)
		if err != nil {
			return err
		}
		if again == nil || again.ID != pending.ID {
			return respond.RequestIsProcessing
		}
		if again.Status == forummodel.ForumImportStatusImported {
			imported = *again
			return nil
		}
		if err := txDAO.FinalizeImport(ctx, pending.ID, created.TaskClassID, created.Title, time.Now()); err != nil {
			return err
		}
		imported = *again
		imported.NewTaskClassID = &created.TaskClassID
		imported.TargetTitle = created.Title
		imported.Status = forummodel.ForumImportStatusImported
		if again.Status != forummodel.ForumImportStatusImported {
			return txDAO.AddPostCounter(ctx, req.PostID, "import_count", 1)
		}
		return nil
	}); err != nil {
		_ = s.forumDAO.MarkImportFailedAfterTaskClassCreated(ctx, pending.ID, created.TaskClassID, created.Title, err.Error(), time.Now())
		return nil, err
	}
	result := importResultFromModel(imported)
	if postAfter, err := s.forumDAO.FindPublishedPost(ctx, req.PostID); err == nil {
		result.ImportCount = postAfter.ImportCount
	}
	return result, nil
}

func (s *Service) reserveImport(ctx context.Context, req forumcontracts.ImportForumPostRequest, authorUserID uint64, targetTitle string, idempotencyKey string) (*forummodel.ForumImport, error) {
	var reserved *forummodel.ForumImport
	if err := s.forumDAO.Transaction(ctx, func(txDAO *forumdao.ForumDAO) error {
		if _, err := txDAO.LockPublishedPost(ctx, req.PostID); err != nil {
			return normalizeRecordNotFound(err, respond.UserTaskClassNotFound)
		}
		existing, err := txDAO.FindImport(ctx, req.PostID, req.ActorUserID)
		if err != nil {
			return err
		}
		if existing != nil {
			switch existing.Status {
			case forummodel.ForumImportStatusImported:
				reserved = existing
				return nil
			case forummodel.ForumImportStatusPending:
				return respond.RequestIsProcessing
			case forummodel.ForumImportStatusFailed:
				if existing.NewTaskClassID != nil {
					reserved = existing
					return nil
				}
				if err := txDAO.UpdateImportProcessing(ctx, existing.ID, targetTitle, time.Now()); err != nil {
					return err
				}
				existing.Status = forummodel.ForumImportStatusPending
				existing.TargetTitle = targetTitle
				reserved = existing
				return nil
			}
		}
		item := &forummodel.ForumImport{
			PostID:         req.PostID,
			UserID:         req.ActorUserID,
			AuthorUserID:   authorUserID,
			TargetTitle:    targetTitle,
			Status:         forummodel.ForumImportStatusPending,
			EventID:        forumImportEventID(req.PostID, req.ActorUserID),
			IdempotencyKey: stringPtrFromNonEmpty(idempotencyKey),
		}
		if err := txDAO.CreateImport(ctx, item); err != nil {
			return err
		}
		reserved = item
		return nil
	}); err != nil {
		return nil, err
	}
	return reserved, nil
}

func (s *Service) recoverCreatedImport(ctx context.Context, req forumcontracts.ImportForumPostRequest, existing forummodel.ForumImport) (*forumcontracts.ImportForumPostResult, error) {
	if existing.NewTaskClassID == nil {
		return nil, respond.RequestIsProcessing
	}
	imported := existing
	if err := s.forumDAO.Transaction(ctx, func(txDAO *forumdao.ForumDAO) error {
		if _, err := txDAO.LockPublishedPost(ctx, req.PostID); err != nil {
			return normalizeRecordNotFound(err, respond.UserTaskClassNotFound)
		}
		again, err := txDAO.FindImport(ctx, req.PostID, req.ActorUserID)
		if err != nil {
			return err
		}
		if again == nil || again.ID != existing.ID {
			return respond.RequestIsProcessing
		}
		if again.Status == forummodel.ForumImportStatusImported {
			imported = *again
			return nil
		}
		if again.Status != forummodel.ForumImportStatusFailed || again.NewTaskClassID == nil {
			return respond.RequestIsProcessing
		}
		if err := txDAO.FinalizeImport(ctx, again.ID, *again.NewTaskClassID, again.TargetTitle, time.Now()); err != nil {
			return err
		}
		imported = *again
		imported.Status = forummodel.ForumImportStatusImported
		return txDAO.AddPostCounter(ctx, req.PostID, "import_count", 1)
	}); err != nil {
		return nil, err
	}
	result := importResultFromModel(imported)
	if postAfter, err := s.forumDAO.FindPublishedPost(ctx, req.PostID); err == nil {
		result.ImportCount = postAfter.ImportCount
	}
	return result, nil
}

func importResultFromModel(item forummodel.ForumImport) *forumcontracts.ImportForumPostResult {
	var newTaskClassID uint64
	if item.NewTaskClassID != nil {
		newTaskClassID = *item.NewTaskClassID
	}
	return &forumcontracts.ImportForumPostResult{
		ImportID:       item.ID,
		PostID:         item.PostID,
		NewTaskClassID: newTaskClassID,
		TaskClassTitle: item.TargetTitle,
		CreatedAt:      formatTime(item.CreatedAt),
	}
}

func forumImportEventID(postID uint64, userID uint64) string {
	return fmt.Sprintf("forum.post.imported:%d:%d", postID, userID)
}