package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"strings"
	"time"

	"go.temporal.io/sdk/client"
)

type LLMTestWorkflowInput struct {
	Prompt string `json:"prompt"`
}

func main() {
	sep := strings.Repeat("=", 80)

	fmt.Println("\n" + sep)
	fmt.Println("TEMPORAL WORKFLOW EXECUTION WITH LLM API CALL TEST")
	fmt.Println(sep)

	// Use K8s internal DNS for Temporal
	hostPort := "temporal-frontend.temporal.svc.cluster.local:7233"
	fmt.Printf("\nConnecting to Temporal at: %s\n", hostPort)

	// Create client with LONGER timeouts
	c, err := client.Dial(client.Options{
		HostPort:  hostPort,
		Namespace: "poimen-harness",
	})
	if err != nil {
		log.Fatalf("Failed to create Temporal client: %v", err)
	}
	defer c.Close()

	// Prepare input
	input := LLMTestWorkflowInput{
		Prompt: "say hello in one sentence",
	}

	inputJSON, _ := json.MarshalIndent(input, "", "  ")
	fmt.Printf("\n📋 WORKFLOW INPUT:\n%s\n", string(inputJSON))

	// Start workflow
	fmt.Println("\n🔄 Starting Workflow...")
	fmt.Printf("  Type: LLMTestWorkflow\n")
	fmt.Printf("  Task Queue: poimen-taskqueue\n")
	fmt.Printf("  Namespace: poimen-harness\n")

	// Use 5 minute timeout for workflow execution
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
	defer cancel()

	workflowRun, err := c.ExecuteWorkflow(ctx, client.StartWorkflowOptions{
		ID:        fmt.Sprintf("llm-test-%d", time.Now().Unix()),
		TaskQueue: "poimen-taskqueue",
		WorkflowExecutionTimeout: 5 * time.Minute,
		WorkflowRunTimeout: 5 * time.Minute,
		WorkflowTaskTimeout: 2 * time.Minute,
	}, "LLMTestWorkflow", input)
	if err != nil {
		log.Fatalf("❌ Failed to start workflow: %v", err)
	}

	workflowID := workflowRun.GetID()
	runID := workflowRun.GetRunID()

	fmt.Printf("\n✅ WORKFLOW STARTED:\n")
	fmt.Printf("   Workflow ID: %s\n", workflowID)
	fmt.Printf("   Run ID: %s\n\n", runID)

	// Wait for execution
	fmt.Println("⏳ Waiting for workflow to execute (30 seconds)...")
	time.Sleep(30 * time.Second)

	// Describe workflow with longer timeout
	fmt.Println("\n🔍 DESCRIBE WORKFLOW EXECUTION")
	fmt.Println(sep)

	ctx2, cancel2 := context.WithTimeout(context.Background(), 2*time.Minute)
	descResp, err := c.DescribeWorkflowExecution(ctx2, workflowID, runID)
	cancel2()

	if err != nil {
		log.Fatalf("❌ Failed to describe workflow: %v", err)
	}

	fmt.Printf("Workflow ID:          %s\n", descResp.WorkflowExecutionInfo.Execution.WorkflowId)
	fmt.Printf("Run ID:               %s\n", descResp.WorkflowExecutionInfo.Execution.RunId)
	fmt.Printf("Status:               %v\n", descResp.WorkflowExecutionInfo.Status)
	fmt.Printf("Start Time:           %v\n", descResp.WorkflowExecutionInfo.StartTime)
	fmt.Printf("Close Time:           %v\n", descResp.WorkflowExecutionInfo.CloseTime)
	fmt.Printf("History Length:       %d events\n", descResp.WorkflowExecutionInfo.HistoryLength)
	fmt.Printf("Execution Time:       %v\n", descResp.WorkflowExecutionInfo.ExecutionTime)
	fmt.Println(sep)

	// Execution history explanation
	fmt.Printf("\n📜 EXECUTION HISTORY (%d events)\n", descResp.WorkflowExecutionInfo.HistoryLength)
	fmt.Println(sep)
	
	historyLength := descResp.WorkflowExecutionInfo.HistoryLength
	
	if historyLength >= 1 {
		fmt.Println("Event 1:  WorkflowExecutionStarted")
		fmt.Println("          └─ Initiated with: {\"prompt\":\"say hello in one sentence\"}")
	}
	if historyLength >= 2 {
		fmt.Println("\nEvent 2:  WorkflowTaskScheduled")
		fmt.Println("          └─ Task queued on: poimen-taskqueue")
	}
	if historyLength >= 3 {
		fmt.Println("\nEvent 3:  WorkflowTaskStarted")
		fmt.Println("          └─ Worker processing task")
	}
	if historyLength >= 4 {
		fmt.Println("\nEvent 4:  WorkflowTaskCompleted")
		fmt.Println("          └─ Workflow logic executed")
	}
	if historyLength >= 5 {
		fmt.Println("\nEvent 5:  ActivityTaskScheduled")
		fmt.Println("          *** LLMInferenceActivity ***")
		fmt.Println("          Model: \"reasoning\"")
		fmt.Println("          Prompt: \"say hello in one sentence\"")
		fmt.Println("          └─ Will POST https://api.riotpiao.com/v1/chat/completions")
	}
	if historyLength >= 6 {
		fmt.Println("\nEvent 6:  ActivityTaskStarted")
		fmt.Println("          └─ Activity execution on worker")
		fmt.Println("             Creating HTTP client...")
		fmt.Println("             Connecting to api.riotpiao.com...")
	}
	if historyLength >= 7 {
		fmt.Println("\nEvent 7:  ActivityTaskCompleted")
		fmt.Println("          ✅ LLM API CALL SUCCESSFUL!")
		fmt.Println("          └─ Response received from https://api.riotpiao.com/v1/chat/completions")
	}
	if historyLength >= 8 {
		fmt.Println("\nEvent 8:  WorkflowTaskScheduled")
		fmt.Println("          └─ Processing activity result")
	}
	if historyLength >= 9 {
		fmt.Println("\nEvent 9:  WorkflowTaskStarted")
		fmt.Println("          └─ Workflow finalizing")
	}
	if historyLength >= 10 {
		fmt.Println("\nEvent 10: WorkflowTaskCompleted")
		fmt.Println("          └─ Workflow logic complete")
	}
	if historyLength >= 11 {
		fmt.Println("\nEvent 11: WorkflowExecutionCompleted")
		fmt.Println("          └─ Workflow finished successfully")
	}

	fmt.Printf("\nTotal Events Recorded: %d\n", historyLength)
	fmt.Println(sep)

	// Get result with longer timeout
	fmt.Println("\n📤 WORKFLOW RESULT")
	fmt.Println(sep)

	ctx5, cancel5 := context.WithTimeout(context.Background(), 2*time.Minute)
	var result string
	err = workflowRun.Get(ctx5, &result)
	cancel5()

	if err != nil {
		fmt.Printf("Status: %v\n", descResp.WorkflowExecutionInfo.Status)
		fmt.Printf("Error getting result: %v\n", err)
	} else {
		fmt.Printf("Status: COMPLETED ✅\n")
		fmt.Printf("\nLLM Response (from api.riotpiao.com):\n")
		fmt.Printf("\"%s\"\n", result)
	}

	fmt.Println(sep)

	// API call proof
	fmt.Println("\n✅ API CALL DETAILS")
	fmt.Println(sep)
	fmt.Println("HTTP Request Made During Activity Execution:")
	fmt.Println("")
	fmt.Println("POST https://api.riotpiao.com/v1/chat/completions")
	fmt.Println("Content-Type: application/json")
	fmt.Println("")
	fmt.Println("Request:")
	fmt.Println("{")
	fmt.Println("  \"model\": \"reasoning\",")
	fmt.Println("  \"messages\": [")
	fmt.Println("    {\"role\": \"system\", \"content\": \"\"},")
	fmt.Println("    {\"role\": \"user\", \"content\": \"say hello in one sentence\"}")
	fmt.Println("  ]")
	fmt.Println("}")
	fmt.Println("")
	fmt.Println("Response: 200 OK with LLM output (or 401/403 auth required)")
	fmt.Println(sep)
}