use dioxus_core::{
    ElementId,
    WriteMutations,
};
use freya_common::{
    Layers,
    ParagraphElements,
};
use freya_native_core::{
    prelude::{
        DioxusState,
        NodeImmutable,
    },
    tree::TreeRef,
    NodeId,
};
use freya_node_state::{
    CursorState,
    LayerState,
};
use rustc_hash::FxHashMap;
use torin::torin::Torin;

use crate::prelude::{
    DioxusDOM,
    DioxusDOMAdapter,
    DioxusDOMAdapterCache,
};

macro_rules! create_mutation_writer {
    ($self:ident) => {
        $self
            .dioxus_integration_state
            .create_mutation_writer(&mut $self.rdom)
    };
}

pub struct MutationsWriter<'a> {
    pub dioxus_integration_state: &'a mut DioxusState,
    pub layout: &'a mut Torin<NodeId>,
    pub layers: &'a Layers,
    pub paragraphs: &'a ParagraphElements,
    pub dioxus_dom_adapter_cache: &'a mut FxHashMap<NodeId, bool>,
    pub scale_factor: f32,
    pub rdom: &'a mut DioxusDOM,
}

impl<'a> MutationsWriter<'a> {
    pub fn remove(&mut self, id: ElementId) {
        let node_id = self.dioxus_integration_state.element_to_node_id(id);

        let mut dom_adapter = DioxusDOMAdapter::new_with_cache(
            self.rdom,
            self.scale_factor,
            DioxusDOMAdapterCache::Controlled(self.dioxus_dom_adapter_cache),
        );

        // Remove from layout
        self.layout.remove(node_id, &mut dom_adapter, true);

        // Remove from layers and paragraph elements
        let mut stack = vec![node_id];
        let tree = self.rdom.tree_ref();
        while let Some(node_id) = stack.pop() {
            if let Some(node) = self.rdom.get(node_id) {
                if !node.node_type().is_visible_element() {
                    continue;
                }

                let traverse_children = node
                    .node_type()
                    .tag()
                    .map(|tag| tag.has_children_with_intrinsic_layout())
                    .unwrap_or_default();
                if traverse_children {
                    let children = tree.children_ids_advanced(node_id, false);
                    stack.extend(children.iter().copied().rev());
                }

                // Remove from layers
                let layer_state = node.get::<LayerState>().unwrap();
                self.layers
                    .remove_node_from_layer(node_id, layer_state.layer);

                // Remove from paragraph elements
                let cursor_state = node.get::<CursorState>().unwrap();
                if let Some(cursor_ref) = cursor_state.cursor_ref.as_ref() {
                    self.paragraphs
                        .remove_paragraph(node_id, &cursor_ref.text_id);
                }
            }
        }
    }
}

impl<'a> WriteMutations for MutationsWriter<'a> {
    fn register_template(&mut self, template: dioxus_core::prelude::Template) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.register_template(template);
    }

    fn append_children(&mut self, id: dioxus_core::ElementId, m: usize) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.append_children(id, m);
    }

    fn assign_node_id(&mut self, path: &'static [u8], id: dioxus_core::ElementId) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.assign_node_id(path, id);
    }

    fn create_placeholder(&mut self, id: dioxus_core::ElementId) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.create_placeholder(id);
    }

    fn create_text_node(&mut self, value: &str, id: dioxus_core::ElementId) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.create_text_node(value, id);
    }

    fn hydrate_text_node(&mut self, path: &'static [u8], value: &str, id: dioxus_core::ElementId) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.hydrate_text_node(path, value, id);
    }

    fn load_template(&mut self, name: &'static str, index: usize, id: dioxus_core::ElementId) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.load_template(name, index, id);
    }

    fn replace_node_with(&mut self, id: dioxus_core::ElementId, m: usize) {
        if m > 0 {
            self.remove(id);
        }

        let mut native_writer = create_mutation_writer!(self);

        native_writer.replace_node_with(id, m);
    }

    fn replace_placeholder_with_nodes(&mut self, path: &'static [u8], m: usize) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.replace_placeholder_with_nodes(path, m);
    }

    fn insert_nodes_after(&mut self, id: dioxus_core::ElementId, m: usize) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.insert_nodes_after(id, m);
    }

    fn insert_nodes_before(&mut self, id: dioxus_core::ElementId, m: usize) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.insert_nodes_before(id, m);
    }

    fn set_attribute(
        &mut self,
        name: &'static str,
        ns: Option<&'static str>,
        value: &dioxus_core::AttributeValue,
        id: dioxus_core::ElementId,
    ) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.set_attribute(name, ns, value, id);
    }

    fn set_node_text(&mut self, value: &str, id: dioxus_core::ElementId) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.set_node_text(value, id);
    }

    fn create_event_listener(&mut self, name: &'static str, id: dioxus_core::ElementId) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.create_event_listener(name, id);
    }

    fn remove_event_listener(&mut self, name: &'static str, id: dioxus_core::ElementId) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.remove_event_listener(name, id);
    }

    fn remove_node(&mut self, id: dioxus_core::ElementId) {
        self.remove(id);
        let mut native_writer = create_mutation_writer!(self);
        native_writer.remove_node(id);
    }

    fn push_root(&mut self, id: dioxus_core::ElementId) {
        let mut native_writer = create_mutation_writer!(self);
        native_writer.push_root(id);
    }
}