use std::sync::Arc;

use crate::element::IdState;
use crate::reaction::{BasicReaction, PositiveReaction, Reaction};
use crate::set::{BasicSet, ExtensionsSet, PositiveSet, Set};
use crate::system::{PositiveSystem, System};
use crate::trace::*;
use crate::translator::Translator;

#[test]
fn slice_atoi() {
    let mut translator = Translator::new();

    let reactions = vec![
        (
            vec!["tgfbr", "stat3", "il6r"],
            vec!["tbet", "gata3", "foxp3"],
            vec!["rorgt"],
        ),
        (
            vec!["tgfbr", "stat3", "il21r"],
            vec!["tbet", "gata3", "foxp3"],
            vec!["rorgt"],
        ),
        (vec!["il23r"], vec![], vec!["stat3"]),
        (vec!["il21"], vec![], vec!["il21r"]),
        (vec!["il6"], vec![], vec!["il6r"]),
        (vec!["tcr"], vec!["foxp3"], vec!["nfat"]),
        (vec!["il27", "nfat"], vec![], vec!["stat1"]),
        (vec!["stat1"], vec!["rorgt", "foxp3"], vec!["tbet"]),
    ]
    .iter()
    .map(|r| {
        Reaction::from(
            r.0.iter()
                .map(|el| translator.encode(*el))
                .collect::<Vec<_>>()
                .into(),
            r.1.iter()
                .map(|el| translator.encode(*el))
                .collect::<Vec<_>>()
                .into(),
            r.2.iter()
                .map(|el| translator.encode(*el))
                .collect::<Vec<_>>()
                .into(),
        )
    })
    .collect::<Vec<_>>();

    let elements = [
        (vec!["il23r", "il21"], vec!["tcr"]),
        (vec!["il21r", "stat3", "nfat"], vec!["il27"]),
        (vec!["stat1"], vec![]),
        (vec!["tbet"], vec![]),
    ]
    .iter()
    .map(|elements| SlicingElement {
        context: elements
            .1
            .iter()
            .map(|el| translator.encode(*el))
            .collect::<Vec<_>>()
            .into(),
        reaction_products: elements
            .0
            .iter()
            .map(|el| translator.encode(*el))
            .collect::<Vec<_>>()
            .into(),
    })
    .collect::<Vec<_>>();
    let enabled_reactions = vec![vec![3, 4, 6], vec![7], vec![8]]
        .into_iter()
        .map(|r| EnabledReactions {
            data: r.iter().map(|i| i - 1).collect::<Vec<_>>(),
        })
        .collect::<Vec<_>>();

    let context_elements = ["tgfb", "il6", "tcr", "il27"]
        .iter()
        .map(|el| translator.encode(*el))
        .collect::<Vec<_>>()
        .into();
    let products_elements = [
        "rorgt", "stat3", "il21r", "il6r", "nfat", "stat1", "tbet", "il21",
        "il23r",
    ]
    .iter()
    .map(|el| translator.encode(*el))
    .collect::<Vec<_>>()
    .into();

    let trace: SlicingTrace<Set, Reaction, System> = SlicingTrace {
        elements,
        enabled_reactions,

        reactions: Arc::new(reactions),
        systems: vec![],
        context_elements: Arc::new(context_elements),
        products_elements: Arc::new(products_elements),
    };

    let marking = ["tbet"]
        .iter()
        .map(|el| translator.encode(*el))
        .collect::<Vec<_>>()
        .into();

    let sliced = trace.slice(marking).unwrap();

    let mut reaction_products = sliced
        .elements
        .iter()
        .map(|elements| {
            elements
                .reaction_products
                .iter()
                .map(|el| translator.decode(*el).unwrap())
                .collect::<Vec<_>>()
        })
        .collect::<Vec<_>>();
    reaction_products.iter_mut().for_each(|x| x.sort());
    let mut correct_reaction_products =
        vec![vec![], vec!["nfat"], vec!["stat1"], vec!["tbet"]];
    correct_reaction_products.iter_mut().for_each(|x| x.sort());

    assert_eq!(reaction_products, correct_reaction_products);

    let mut context = sliced
        .elements
        .iter()
        .map(|elements| {
            elements
                .context
                .iter()
                .map(|el| translator.decode(*el).unwrap())
                .collect::<Vec<_>>()
        })
        .collect::<Vec<_>>();
    context.iter_mut().for_each(|x| x.sort());
    let mut correct_context = vec![vec!["tcr"], vec!["il27"], vec![], vec![]];
    correct_context.iter_mut().for_each(|x| x.sort());

    assert_eq!(context, correct_context);

    let mut enabled_reactions = sliced
        .enabled_reactions
        .iter()
        .map(|elements| elements.data.clone())
        .collect::<Vec<_>>();
    enabled_reactions.iter_mut().for_each(|x| x.sort());
    let mut correct_enabled_reactions = vec![vec![5], vec![6], vec![7]];
    correct_enabled_reactions.iter_mut().for_each(|x| x.sort());

    assert_eq!(enabled_reactions, correct_enabled_reactions);
}

#[test]
fn slice_positive_atoi() {
    let mut translator = Translator::new();

    let reactions = {
        let reactions = vec![
            (
                vec!["tgfbr", "stat3", "il6r"],
                vec!["tbet", "gata3", "foxp3"],
                vec!["rorgt"],
            ),
            (
                vec!["tgfbr", "stat3", "il21r"],
                vec!["tbet", "gata3", "foxp3"],
                vec!["rorgt"],
            ),
            (vec!["il23r"], vec![], vec!["stat3"]),
            (vec!["il21"], vec![], vec!["il21r"]),
            (vec!["il6"], vec![], vec!["il6r"]),
            (vec!["tcr"], vec!["foxp3"], vec!["nfat"]),
            (vec!["il27", "nfat"], vec![], vec!["stat1"]),
            (vec!["stat1"], vec!["rorgt", "foxp3"], vec!["tbet"]),
        ]
        .iter()
        .map(|r| {
            Reaction::from(
                r.0.iter()
                    .map(|el| translator.encode(*el))
                    .collect::<Vec<_>>()
                    .into(),
                r.1.iter()
                    .map(|el| translator.encode(*el))
                    .collect::<Vec<_>>()
                    .into(),
                r.2.iter()
                    .map(|el| translator.encode(*el))
                    .collect::<Vec<_>>()
                    .into(),
            )
        })
        .collect::<Vec<_>>();

        let system = System::from(
            Arc::new(crate::environment::Environment::from([])),
            Set::from([]),
            crate::process::Process::Nill,
            Arc::new(reactions),
        );

        let converted_system: PositiveSystem = system.into();
        let mut reactions =
            Arc::try_unwrap(converted_system.reaction_rules).unwrap();
        reactions.sort_by(|a, b| {
            a.reactants
                .cmp(&b.reactants)
                .then(a.products.cmp(&b.products))
        });

        println!("Computed Reactions:");
        for (pos, r) in reactions.iter().enumerate() {
            println!(
                "\t({pos}) {},",
                crate::translator::Formatter::from(&translator, r)
            );
        }
        reactions
    };

    let elements = [
        (
            vec![
                ("il23r", IdState::Positive),
                ("il21", IdState::Positive),
                ("rorgt", IdState::Negative),
                ("stat3", IdState::Negative),
                ("il21r", IdState::Negative),
                ("il6r", IdState::Negative),
                ("nfat", IdState::Negative),
                ("stat1", IdState::Negative),
                ("tbet", IdState::Negative),
                ("tgfbr", IdState::Negative),
                ("foxp3", IdState::Negative),
            ],
            vec![
                ("tcr", IdState::Positive),
                ("tgfb", IdState::Negative),
                ("il6", IdState::Negative),
                ("il27", IdState::Negative),
            ],
        ),
        (
            vec![
                ("il21r", IdState::Positive),
                ("stat3", IdState::Positive),
                ("nfat", IdState::Positive),
                ("rorgt", IdState::Negative),
                ("il6r", IdState::Negative),
                ("stat1", IdState::Negative),
                ("tbet", IdState::Negative),
                ("il21", IdState::Negative),
                ("il23r", IdState::Negative),
                ("tgfbr", IdState::Negative),
                ("foxp3", IdState::Negative),
            ],
            vec![
                ("il27", IdState::Positive),
                ("tgfb", IdState::Negative),
                ("il6", IdState::Negative),
                ("tcr", IdState::Negative),
            ],
        ),
        (
            vec![
                ("stat1", IdState::Positive),
                ("rorgt", IdState::Negative),
                ("stat3", IdState::Negative),
                ("il21r", IdState::Negative),
                ("il6r", IdState::Negative),
                ("nfat", IdState::Negative),
                ("tbet", IdState::Negative),
                ("il21", IdState::Negative),
                ("il23r", IdState::Negative),
                ("tgfbr", IdState::Negative),
                ("foxp3", IdState::Negative),
            ],
            vec![
                ("il27", IdState::Negative),
                ("tgfb", IdState::Negative),
                ("il6", IdState::Negative),
                ("tcr", IdState::Negative),
            ],
        ),
        (
            vec![
                ("tbet", IdState::Positive),
                ("rorgt", IdState::Negative),
                ("stat3", IdState::Negative),
                ("il21r", IdState::Negative),
                ("il6r", IdState::Negative),
                ("nfat", IdState::Negative),
                ("stat1", IdState::Negative),
                ("il21", IdState::Negative),
                ("il23r", IdState::Negative),
                ("tgfbr", IdState::Negative),
                ("foxp3", IdState::Negative),
            ],
            vec![],
        ),
    ]
    .iter()
    .map(|elements| SlicingElement {
        context: Into::<PositiveSet>::into(
            elements
                .1
                .iter()
                .map(|el| (translator.encode(el.0), el.1))
                .collect::<Vec<_>>(),
        ),
        reaction_products: Into::<PositiveSet>::into(
            elements
                .0
                .iter()
                .map(|el| (translator.encode(el.0), el.1))
                .collect::<Vec<_>>(),
        ),
    })
    .collect::<Vec<_>>();

    let enabled_reactions = {
        let mut enabled_reactions = vec![];
        for slice_el in elements.iter().rev().skip(1).rev() {
            let available_enteties =
                slice_el.context.union(&slice_el.reaction_products);
            enabled_reactions.push(vec![]);
            for (pos, r) in reactions.iter().enumerate() {
                if r.enabled(&available_enteties) {
                    enabled_reactions.last_mut().unwrap().push(pos);
                }
            }
        }
        enabled_reactions
            .into_iter()
            .map(|r| EnabledReactions { data: r })
            .collect::<Vec<_>>()
    };

    let context_elements = Into::<Set>::into(
        ["tgfb", "il6", "tcr", "il27"]
            .iter()
            .map(|el| translator.encode(*el))
            .collect::<Vec<_>>(),
    )
    .to_positive_set(IdState::Positive);
    let products_elements = Into::<Set>::into(
        [
            "rorgt", "stat3", "il21r", "il6r", "nfat", "stat1", "tbet", "il21",
            "il23r", "tgfbr", "foxp3",
        ]
        .iter()
        .map(|el| translator.encode(*el))
        .collect::<Vec<_>>(),
    )
    .to_positive_set(IdState::Positive);

    let trace: SlicingTrace<PositiveSet, PositiveReaction, PositiveSystem> =
        SlicingTrace {
            elements,
            enabled_reactions,

            reactions: Arc::new(reactions),
            systems: vec![],
            context_elements: Arc::new(context_elements),
            products_elements: Arc::new(products_elements),
        };

    let marking = Into::<Set>::into(
        ["tbet"]
            .iter()
            .map(|el| translator.encode(*el))
            .collect::<Vec<_>>(),
    )
    .to_positive_set(IdState::Positive);

    let sliced = trace.slice(marking).unwrap();

    let mut reaction_products = sliced
        .elements
        .iter()
        .map(|elements| {
            elements
                .reaction_products
                .iter()
                .map(|el| (translator.decode(*el.0).unwrap(), *el.1))
                .collect::<Vec<_>>()
        })
        .collect::<Vec<_>>();
    reaction_products.iter_mut().for_each(|x| x.sort());
    let mut correct_reaction_products: Vec<Vec<(String, IdState)>> = [
        vec![("foxp3", IdState::Negative)],
        vec![("nfat", IdState::Positive), ("tgfbr", IdState::Negative)],
        vec![
            ("stat1", IdState::Positive),
            ("foxp3", IdState::Negative),
            ("rorgt", IdState::Negative),
        ],
        vec![("tbet", IdState::Positive)],
    ]
    .iter()
    .map(|x| x.iter().map(|y| (y.0.to_string(), y.1)).collect::<Vec<_>>())
    .collect::<Vec<_>>();
    correct_reaction_products.iter_mut().for_each(|x| x.sort());

    assert_eq!(reaction_products, correct_reaction_products);

    let mut context = sliced
        .elements
        .iter()
        .map(|elements| {
            elements
                .context
                .iter()
                .map(|el| (translator.decode(*el.0).unwrap(), *el.1))
                .collect::<Vec<_>>()
        })
        .collect::<Vec<_>>();
    context.iter_mut().for_each(|x| x.sort());
    let mut correct_context = [
        vec![("tcr", IdState::Positive)],
        vec![("il27", IdState::Positive)],
        vec![],
        vec![],
    ]
    .iter()
    .map(|x| x.iter().map(|y| (y.0.to_string(), y.1)).collect::<Vec<_>>())
    .collect::<Vec<_>>();
    correct_context.iter_mut().for_each(|x| x.sort());

    assert_eq!(context, correct_context);

    let mut enabled_reactions = sliced
        .enabled_reactions
        .iter()
        .map(|elements| elements.data.clone())
        .collect::<Vec<_>>();
    enabled_reactions.iter_mut().for_each(|x| x.sort());
    let mut correct_enabled_reactions = vec![vec![11], vec![2, 20], vec![10]];
    correct_enabled_reactions.iter_mut().for_each(|x| x.sort());

    assert_eq!(enabled_reactions, correct_enabled_reactions);
}