package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"

	"github.com/edgedb/edgedb-go"
	"github.com/gofiber/fiber/v2"
)

type DeepseekChatCompletionRequest struct {
	Model       string           `json:"model"`
	Messages    []RequestMessage `json:"messages"`
	MaxTokens   int              `json:"max_tokens"`
	Temperature float64          `json:"temperature"`
}

type DeepseekChatCompletionResponse struct {
	ID      string           `json:"id"`
	Object  string           `json:"object"`
	Created int64            `json:"created"`
	Model   string           `json:"model"`
	Usage   DeepseekUsage    `json:"usage"`
	Choices []DeepseekChoice `json:"choices"`
}

type DeepseekUsage struct {
	PromptTokens     int32 `json:"prompt_tokens"`
	CompletionTokens int32 `json:"completion_tokens"`
	TotalTokens      int32 `json:"total_tokens"`
}

type DeepseekChoice struct {
	Message      Message `json:"message"`
	FinishReason string  `json:"finish_reason"`
	Index        int     `json:"index"`
}

func addDeepseekMessage(c *fiber.Ctx, llm LLM, selected bool) edgedb.UUID {
	Messages := getAllSelectedMessages(c)

	chatCompletion, err := RequestDeepseek(c, llm.Model.ModelID, Messages, float64(llm.Temperature), llm.Context, int(llm.MaxToken))
	if err != nil {
		fmt.Println("Error requesting Deepseek: ", err)
		id := insertBotMessage(c, "Error requesting DeepSeek, model may not be available anymore. Better error message in development.", selected, llm.ID)
		return id
	} else if len(chatCompletion.Choices) == 0 {
		fmt.Println("No response from DeepSeek")
		id := insertBotMessage(c, "No response from DeepSeek", selected, llm.ID)
		return id
	} else {
		Content := chatCompletion.Choices[0].Message.Content
		id := insertBotMessage(c, Content, selected, llm.ID)
		return id
	}
}

func TestDeepseekKey(apiKey string) bool {
	url := "https://api.deepseek.com/chat/completions"

	// Convert messages to OpenAI format
	deepseekMessages := []RequestMessage{
		{
			Role:    "user",
			Content: "Hello",
		},
	}

	requestBody := DeepseekChatCompletionRequest{
		Model:       "deepseek-chat",
		Messages:    deepseekMessages,
		Temperature: 0,
		MaxTokens:   10,
	}

	jsonBody, err := json.Marshal(requestBody)
	if err != nil {
		fmt.Println("Failed to test Deepseek API key - json.Marshal :", err)
		return false
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBody))
	if err != nil {
		fmt.Println("Failed to test Deepseek API key - http.NewRequest :", err)
		return false
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+apiKey)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Failed to test Deepseek API key - client.Do :", err)
		return false
	}
	defer resp.Body.Close()

	fmt.Println(resp.Status)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Failed to test Deepseek API key - io.ReadAll :", err)
		return false
	}

	var chatCompletionResponse DeepseekChatCompletionResponse
	err = json.Unmarshal(body, &chatCompletionResponse)
	if err != nil {
		fmt.Println("Failed to test Deepseek API key - json.Marshal :", err)
		return false
	}

	if chatCompletionResponse.Usage.CompletionTokens == 0 {
		fmt.Println("Failed to test Deepseek API key - No completion tokens :", err)
		return false
	}

	return true
}

func RequestDeepseek(c *fiber.Ctx, model string, messages []Message, temperature float64, context string, maxTokens int) (DeepseekChatCompletionResponse, error) {
	var apiKey string
	err := edgeGlobalClient.WithGlobals(map[string]interface{}{"ext::auth::client_token": c.Cookies("jade-edgedb-auth-token")}).QuerySingle(edgeCtx, `
		with
			filtered_keys := (
				select Key {
					key
				} filter .company.name = <str>$0 AND .<keys[is Setting].<setting[is User] = global currentUser
			)
		select filtered_keys.key limit 1
	`, &apiKey, "deepseek")
	if err != nil {
		return DeepseekChatCompletionResponse{}, fmt.Errorf("error getting DeepSeek API key: %w", err)
	}

	url := "https://api.deepseek.com/chat/completions"

	requestBody := DeepseekChatCompletionRequest{
		Model:       model,
		Messages:    Message2RequestMessage(messages, context),
		MaxTokens:   maxTokens,
		Temperature: temperature,
	}

	jsonBody, err := json.Marshal(requestBody)
	if err != nil {
		return DeepseekChatCompletionResponse{}, fmt.Errorf("error marshaling JSON: %w", err)
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBody))
	if err != nil {
		return DeepseekChatCompletionResponse{}, fmt.Errorf("error creating request: %w", err)
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+apiKey)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return DeepseekChatCompletionResponse{}, fmt.Errorf("error sending request: %w", err)
	}
	defer resp.Body.Close()

	// TODO: Add a message to the user and do it for all 400 things
	if resp.Status == "402 Payment Required" {
		return DeepseekChatCompletionResponse{}, fmt.Errorf("error reading response body: %w", err)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return DeepseekChatCompletionResponse{}, fmt.Errorf("error reading response body: %w", err)
	}

	var chatCompletionResponse DeepseekChatCompletionResponse
	err = json.Unmarshal(body, &chatCompletionResponse)
	if err != nil {
		return DeepseekChatCompletionResponse{}, fmt.Errorf("error unmarshaling JSON: %w", err)
	}

	var usedModelInfo ModelInfo
	err = edgeGlobalClient.WithGlobals(map[string]interface{}{"ext::auth::client_token": c.Cookies("jade-edgedb-auth-token")}).QuerySingle(edgeCtx, `
		SELECT ModelInfo {
			inputPrice,
			outputPrice
		}
		FILTER .modelID = <str>$0
		LIMIT 1
	`, &usedModelInfo, model)
	if err != nil {
		return DeepseekChatCompletionResponse{}, fmt.Errorf("error getting model info: %w", err)
	}

	var inputCost float32 = float32(chatCompletionResponse.Usage.PromptTokens) * usedModelInfo.InputPrice
	var outputCost float32 = float32(chatCompletionResponse.Usage.CompletionTokens) * usedModelInfo.OutputPrice
	addUsage(c, inputCost, outputCost, chatCompletionResponse.Usage.PromptTokens, chatCompletionResponse.Usage.CompletionTokens, model)

	return chatCompletionResponse, nil
}