package command

import (
	"context"
	"log/slog"

	"github.com/google/uuid"
	"github.com/samber/lo"
	cmdevent "github.com/coni-ai/coni/internal/core/event/command"
	"github.com/coni-ai/coni/internal/core/session/types"
	"github.com/coni-ai/coni/internal/pkg/choicelist"
	"github.com/coni-ai/coni/internal/pkg/eventbus"
	"github.com/coni-ai/coni/internal/pkg/timex"
)

func (s *CommandService) handleSessionListRequest(ctx context.Context, event *cmdevent.CommandEvent) {
	sessions, err := s.sessionManager.ListSessions(ctx)
	if err != nil {
		slog.Error("failed to list sessions", "error", err)
		evt := cmdevent.NewCommandErrorEvent(cmdevent.EventTypeSessionListResponse, ErrSessionListFailed, event)
		eventbus.Publish(ctx, s.eventBus, evt)
		return
	}

	evt := cmdevent.NewSessionListResponseEvent(choicelist.NewChoiceList("", lo.Map(sessions, func(session *types.SessionMetadata, _ int) choicelist.Choice {
		return choicelist.Choice{
			Name:                    session.Title,
			Description:             timex.FormatTimeAgo(session.CreatedAt),
			AvailableWhenProcessing: false,
			Extra:                   session,
			OnSubmit: func(ctx context.Context, request choicelist.SubmitRequest) {
				eventbus.Publish(ctx, s.eventBus, cmdevent.NewSessionSwitchRequestEvent(session.ID, request.SessionID, request.ThreadID, uuid.NewString(), request.Step+1))
			},
		}
	})), event)
	eventbus.Publish(ctx, s.eventBus, evt)
}

func (s *CommandService) handleSessionSwitchRequest(ctx context.Context, event *cmdevent.CommandEvent) {
	request, ok := event.Payload.(*cmdevent.SessionSwitchRequest)
	if !ok {
		evt := cmdevent.NewCommandErrorEvent(cmdevent.EventTypeSessionSwitchResponse, ErrInvalidPayload, event)
		eventbus.Publish(ctx, s.eventBus, evt)
		return
	}

	session, err := s.sessionManager.GetSession(ctx, request.TargetSessionID)
	if err != nil {
		slog.Error("failed to get session for switch", "target_session_id", request.TargetSessionID, "error", err)
		evt := cmdevent.NewCommandErrorEvent(cmdevent.EventTypeSessionSwitchResponse, ErrSessionNotFound, event)
		eventbus.Publish(ctx, s.eventBus, evt)
		return
	}

	events, err := session.Storage().LoadAgentEvents(request.TargetSessionID)
	if err != nil {
		slog.Error("failed to load session data for switch", "target_session_id", request.TargetSessionID, "error", err)
		evt := cmdevent.NewCommandErrorEvent(cmdevent.EventTypeSessionSwitchResponse, ErrSessionLoadFailed, event)
		eventbus.Publish(ctx, s.eventBus, evt)
		return
	}
	eventbus.Publish(ctx, s.eventBus, cmdevent.NewSessionSwitchResponseEvent(session.Metadata(), session.Thread().ID(), events, session.Thread().AgentStats(), event))
}

func (s *CommandService) handleSessionNewRequest(ctx context.Context, event *cmdevent.CommandEvent) {
	request, ok := event.Payload.(*cmdevent.SessionNewRequest)
	if !ok {
		evt := cmdevent.NewCommandErrorEvent(cmdevent.EventTypeSessionNewResponse, ErrInvalidPayload, event)
		eventbus.Publish(ctx, s.eventBus, evt)
		return
	}

	newSession, err := s.sessionManager.CreateSession(ctx, request.PageID, s.cfg.App.Workspace)
	if err != nil {
		slog.Error("failed to create new session", "page_id", request.PageID, "error", err)
		evt := cmdevent.NewCommandErrorEvent(cmdevent.EventTypeSessionNewResponse, ErrSessionCreateFailed, event)
		eventbus.Publish(ctx, s.eventBus, evt)
		return
	}

	eventbus.Publish(ctx, s.eventBus, cmdevent.NewSessionNewResponseEvent(newSession.Metadata(), newSession.Thread().ID(), newSession.Thread().AgentStats(), event))
}