use std::borrow::Borrow;
use std::hash::{Hash, Hasher};


use serde::{Serialize, Deserialize};

use shm_rs::scheme_composer::composer::from_struct;
use shm_rs::serializator::serializator;

use shm_rs::static_scheme::init;
use shm_rs::dynamic_scheme::environment;


#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum Mode 
{ 
    Attempts, 

    Instant, 

    Scoring
}


#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct LdFilterOverrides 
{ 
    pub search_win: Option<i64>,
    pub retry_cnt: Option<u64>,
    pub max_score: Option<u64>,
    pub ban_time: Option<i64>,
    pub ign_hosts: Option<Vec<String>>,
    pub ign_users: Option<Vec<String>>
}


#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct LdFilterDefs 
{ 
    pub key: String,
    pub val: String
}


#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct LdFilterSets 
{ 
    pub title: String,
    pub list: std::collections::HashSet<String>
}


/// 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), 

    /// 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 LdMonFilActsOver 
{ 
    pub key: String,
    pub val: ShmTypeAnyField
}


#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct LdMonFilActs 
{ 
    pub action_name: String,
    pub override_map: Option<Vec<LdMonFilActsOver>>
}


#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum RuleGroupType 
{ 
    Any(Vec<RuleGroupType>), 

    Not(Vec<RuleGroupType>), 

    All(Vec<RuleGroupType>), 

    Regex{ regex: String, score: Option<u64>, descr: Option<String> }, 

    Literal{ literal: String, score: Option<u64>, descr: Option<String> }
}


#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct LdFilterRuleset 
{ 
    pub ruleset_name: String,
    pub sub_appnames: Option<std::collections::HashSet<String>>,
    pub actions: Option<Vec<LdMonFilActs>>,
    pub rules: Vec<RuleGroupType>
}


#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct LdFilter 
{ 
    pub mode: Mode,
    pub overr_vars: Option<LdFilterOverrides>,
    pub defmap: Option<Vec<LdFilterDefs>>,
    pub decsets: Option<std::collections::HashSet<LdFilterSets>>,
    pub usesets: Option<String>,
    pub appname: Option<String>,
    pub rulesets: std::collections::HashSet<LdFilterRuleset>
}

impl Eq for LdFilterSets {}

impl PartialEq for LdFilterSets
{
    fn eq(&self, other: &Self) -> bool 
    {
        self.title == other.title
    }
}

impl Hash for LdFilterSets 
{
    fn hash<H: Hasher>(&self, state: &mut H) 
    {
        self.title.hash(state);
    }
}

impl Borrow<String> for LdFilterSets
{
    fn borrow(&self) -> &String 
    {
        &self.title
    }
}

impl Eq for LdFilterRuleset {}

impl PartialEq for LdFilterRuleset
{
    fn eq(&self, other: &Self) -> bool 
    {
        self.ruleset_name == other.ruleset_name
    }
}

impl Hash for LdFilterRuleset 
{
    fn hash<H: Hasher>(&self, state: &mut H) 
    {
        self.ruleset_name.hash(state);
    }
}

impl Borrow<String> for LdFilterRuleset
{
    fn borrow(&self) -> &String 
    {
        &self.ruleset_name
    }
}


pub fn main()
{

// static
    let mut curdir = std::env::current_dir().unwrap();
    curdir.push("examples/struct_to_scheme/advanced3");
    println!("{}", curdir.display());

    let schm = init::SchemeInit::new_with_path(curdir).unwrap();
    let res = schm.run_from_file("filters.shm", None).unwrap();
    let resser = res.get("filters").unwrap().clone();

// dynamic
    let mut curdir = std::env::current_dir().unwrap();
    curdir.push("examples/struct_to_scheme/advanced3/nginx.shm");
    let (_, dynres) = 
        environment::DynEnvironment::from_file(curdir, resser.clone()).unwrap();

// serialize dyn
    let ret = serializator::Serialization::serialize(resser.clone(), dynres.clone()).unwrap();

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

/*
    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);
        }
    }
*/

    let n: LdFilter = serde_json::from_str(&serialized).unwrap();

    let resser = from_struct(n, resser);
    
    if resser.is_err() == true
    {
        panic!("{}", resser.err().unwrap());
    }
    else
    {
        println!("{}", resser.unwrap());
    }
}