package main

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

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
)

type OpenaiChatCompletionRequest struct {
	Model       string          `json:"model"`
	Messages    []OpenaiMessage `json:"messages"`
	Temperature float64         `json:"temperature"`
}

type OpenaiMessage struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

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

type OpenaiUsage struct {
	PromptTokens     int `json:"prompt_tokens"`
	CompletionTokens int `json:"completion_tokens"`
	TotalTokens      int `json:"total_tokens"`
}

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

func init() {
	var ModelInfosList = []ModelInfo{}

	modelInfo := ModelInfo{
		ID:          "gpt-3.5-turbo",
		Name:        "GPT-3.5",
		Icon:        "openai",
		MaxToken:    4096,
		InputPrice:  0.50 / 1000000,
		OutputPrice: 1.50 / 1000000,
	}
	ModelInfosList = append(ModelInfosList, modelInfo)

	modelInfo = ModelInfo{
		ID:          "gpt-4-turbo",
		Name:        "GPT-4",
		Icon:        "openai",
		MaxToken:    8192,
		InputPrice:  10.00 / 1000000,
		OutputPrice: 30.00 / 1000000,
	}
	ModelInfosList = append(ModelInfosList, modelInfo)

	companyInfo := CompanyInfo{
		ID:         "openai",
		Name:       "OpenAI",
		Icon:       "icons/openai.png",
		ModelInfos: ModelInfosList,
	}
	CompanyInfos = append(CompanyInfos, companyInfo)
}

func addOpenaiMessage(modelID string, selected bool) string {
	Messages := getAllMessages()

	chatCompletion, err := RequestOpenai(modelID, Messages, 0.7)
	if err != nil {
		fmt.Println("Error:", err)
	} else if len(chatCompletion.Choices) == 0 {
		fmt.Println(chatCompletion)
		fmt.Println("No response from OpenAI")
		collection := mongoClient.Database("chat").Collection("messages")
		response, err := collection.InsertOne(context.Background(), bson.M{"message": "no response", "role": "bot", "date": time.Now(), "model": modelID, "selected": selected})
		if err != nil {
			fmt.Println(err)
		}
		return response.InsertedID.(primitive.ObjectID).Hex()
	} else {
		Content := chatCompletion.Choices[0].Message.Content
		collection := mongoClient.Database("chat").Collection("messages")
		response, err := collection.InsertOne(context.Background(), bson.M{"message": Content, "role": "bot", "date": time.Now(), "model": modelID, "selected": selected})
		if err != nil {
			fmt.Println(err)
		}
		return response.InsertedID.(primitive.ObjectID).Hex()
	}
	return ""
}

func Messages2OpenaiMessages(messages []Message) []OpenaiMessage {
	openaiMessages := make([]OpenaiMessage, len(messages))
	for i, msg := range messages {
		var role string
		switch msg.Role {
		case "user":
			role = "user"
		case "bot":
			role = "assistant"
		default:
			role = "system"
		}
		openaiMessages[i] = OpenaiMessage{
			Role:    role,
			Content: msg.Content,
		}
	}
	return openaiMessages
}

func RequestOpenai(model string, messages []Message, temperature float64) (OpenaiChatCompletionResponse, error) {
	apiKey := "sk-proj-f7StCvXCtcmiOOayiVmgT3BlbkFJlVtAcOo3JcrnGq1cPa5o" // TODO Use env variable
	url := "https://api.openai.com/v1/chat/completions"

	// Convert messages to OpenAI format
	openaiMessages := Messages2OpenaiMessages(messages)

	requestBody := OpenaiChatCompletionRequest{
		Model:       model,
		Messages:    openaiMessages,
		Temperature: temperature,
	}

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

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBody))
	if err != nil {
		return OpenaiChatCompletionResponse{}, 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 OpenaiChatCompletionResponse{}, fmt.Errorf("error sending request: %w", err)
	}
	defer resp.Body.Close()

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

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

	return chatCompletionResponse, nil
}