use serde::{Serialize, Deserialize};

use shm_rs::static_scheme::generator::RustCode;
use shm_rs::static_scheme::init;
use shm_rs::dynamic_scheme::environment;
use shm_rs::serializator::serializator;

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum MyEnum 
{ 
    Item1, 

    Item2
}


pub const TEST_SYMBOL: &'static str = "test1234";

/// An enum for the auto type 
#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum ShmTypeAnyField 
{ 
    /// An integer data type
    Int(i64), 

    /// An unsigned integer type
    UInt(u64), 

    /// An integer data type
    LongInt(i64), 

    /// An unsigned integer type
    LongUInt(u64), 

    /// A boolean type
    Bool(bool), 

    /// A string type
    String(String), 

    /// An entity type
    Entity(String), 

    /// A variable type
    Variable(String)
}


#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TestStruct 
{ 
    pub auto_field: ShmTypeAnyField,
    pub auto_u128: ShmTypeAnyField,
    pub auto_vec: Vec<ShmTypeAnyField>,
    pub auto_symb: ShmTypeAnyField,
    pub auto_enum: ShmTypeAnyField
}

fn main()
{
    let curdir = std::env::current_dir().unwrap();

    println!("{}", curdir.display());

    let schm = init::SchemeInit::new_with_path(curdir).unwrap();

    let res = schm.run_from_file("examples/scheme_auto/test_auto_init.shm", None).unwrap();

    let resser = res.get("test_auto").unwrap().clone();

    let mut curdir = std::env::current_dir().unwrap();

    curdir.push("examples/scheme_auto/test_auto_data.shm");

   // let lex = lexer::Lexer::from_file(curdir).unwrap();
    let (_dynenv, dyn_res) = 
        environment::DynEnvironment::from_file(curdir, resser.clone()).unwrap();
   // let dynenv = environment::DynEnvironment::new_root(resser.clone());

    //let dyn_res = environment::DynEnvironment::run(&lex, dynenv).unwrap();

    let ret = serializator::Serialization::serialize(resser.clone(), dyn_res.clone()).unwrap();

    let serialized = serde_json::to_string(&ret).unwrap();

        // control

        let ctrl_struct = 
        TestStruct
        { 
            auto_field: ShmTypeAnyField::UInt(4),
            auto_u128: ShmTypeAnyField::LongUInt(128),
            auto_vec: vec![ShmTypeAnyField::String("test".to_string()), ShmTypeAnyField::Int(34), ShmTypeAnyField::UInt(34), ShmTypeAnyField::Bool(true)],
            auto_symb: ShmTypeAnyField::String(String::from("test1234")),
            auto_enum: ShmTypeAnyField::String(String::from("Item1")),
        };
    let ctrl_struct_ser = serde_json::to_string(&ctrl_struct).unwrap();

    println!("Control:\n{}\n", ctrl_struct_ser);

    println!("Serialized Result:\n{}", serialized);

    let deserialized: TestStruct = serde_json::from_str(&serialized).unwrap();

    println!("Deserialized result: \n{:?}", deserialized);




    if ctrl_struct_ser != serialized
    {
        panic!("not equal");
    }
    else
    {
        println!("OK");
    }


    let mut rc = RustCode::new(&["Clone", "Debug", "Serialize", "Deserialize"], &["Clone", "Debug", "Serialize", "Deserialize"]);
    println!("Structures: ");
    match resser.generate_rust_structs(&mut rc)
    {
        Ok(_) => 
        {
            println!("{}", rc);
        },
        Err(e) => 
        {
            println!("{}", e);
        }
    }

}