#![allow(dead_code)]

use std::future::Future;

use serde::{Deserialize, Serialize};
use serde_json::Number;

use crate::appstate::Chat;

pub mod openai;

// impl AiSpec for Provider {
//     async fn send_message(&self, chat: &Chat) -> anyhow::Result<String> {
//         match self {
//             Provider::OpenAI(open_ai) => open_ai.send_message(chat).await,
//         }
//     }

//     async fn fetch_models(&self) -> anyhow::Result<Vec<Model>> {
//         match self {
//             Provider::OpenAI(open_ai) => open_ai.fetch_models().await,
//         }
//     }

//     async fn list_models(&self) -> Vec<Model> {
//         match self {
//             Provider::OpenAI(open_ai) => open_ai.list_models().await,
//         }
//     }
// }

/// An AI model
#[derive(PartialEq, Clone, Debug, Deserialize, Serialize)]
pub struct Model {
    pub id: String,
    pub name: String,
    pub created: Number,
    pub object: String,
    pub owned_by: String,
}

// pub struct ChunkedMessage {
//     pub id: u32,
//     pub event: ChunkedMessageEvent,
// }

pub enum ChunkedMessageEvent {
    ThinkingEvent { text: String },
    ThinkingEnd,
    ResponseEvent { text: String },
    ResponseEnd,
    ToolCallEvent {},
    Error { reason: String },
}

pub trait AiSpec {
    /// Sends a message to the LLM
    fn send_message(&self, chat: &Chat) -> impl Future<Output = anyhow::Result<String>> + Send;

    /// Sends a message to the provider and get a chunked response.
    fn send_message_chunked(
        &self,
        chat: Chat,
    ) -> impl Future<Output = anyhow::Result<impl futures_core::Stream<Item = ChunkedMessageEvent>>> + Send;

    /// Fetches the models from the provider, and returns them
    fn fetch_models(&self) -> impl Future<Output = anyhow::Result<Vec<Model>>> + Send;

    /// Returns the fetched models (doesn't make an API call)
    fn list_models(&self) -> impl Future<Output = Vec<Model>> + Send;
}