use crate::elements::*;

use indextree::{Arena, NodeId};
use jetscii::bytes;
use memchr::{memchr_iter, memrchr_iter};

pub struct Org<'a> {
    pub(crate) arena: Arena<Element<'a>>,
    pub(crate) root: NodeId,
    text: &'a str,
}

impl<'a> Org<'a> {
    pub fn new(text: &'a str) -> Self {
        let mut arena = Arena::new();
        let root = arena.new_node(Element::Document {
            begin: 0,
            end: text.len(),
        });

        Org { arena, root, text }
    }

    pub fn finish(&self) -> bool {
        self.arena[self.root].first_child().is_some()
    }

    pub fn parse(&mut self) {
        if self.finish() {
            return;
        }

        let mut node = self.root;
        loop {
            match self.arena[node].data {
                Element::Document { begin, end, .. }
                | Element::Headline {
                    contents_begin: begin,
                    contents_end: end,
                    ..
                } => {
                    let mut begin = begin;
                    if begin < end {
                        let off = Headline::find_level(&self.text[begin..end], std::usize::MAX);
                        if off != 0 {
                            let (contents_begin, contents_end) =
                                skip_empty_lines(&self.text[begin..begin + off]);
                            let section = Element::Section {
                                begin,
                                end: begin + off,
                                contents_begin: begin + contents_begin,
                                contents_end: begin + contents_end,
                            };
                            let new_node = self.arena.new_node(section);
                            node.append(new_node, &mut self.arena).unwrap();
                            begin += off;
                        }
                    }
                    while begin < end {
                        let (headline, off, end) = Headline::parse(&self.text[begin..end], &[]);
                        let headline = Element::Headline {
                            headline,
                            begin,
                            end: begin + end,
                            contents_begin: begin + off,
                            contents_end: begin + end,
                        };
                        let new_node = self.arena.new_node(headline);
                        node.append(new_node, &mut self.arena).unwrap();
                        begin += end;
                    }
                }
                Element::Section {
                    contents_begin,
                    contents_end,
                    ..
                }
                | Element::Block {
                    contents_begin,
                    contents_end,
                    ..
                }
                | Element::ListItem {
                    contents_begin,
                    contents_end,
                    ..
                } => {
                    self.parse_elements_children(contents_begin, contents_end, node);
                }
                Element::Paragraph {
                    contents_begin,
                    contents_end,
                    ..
                }
                | Element::Bold {
                    contents_begin,
                    contents_end,
                    ..
                }
                | Element::Underline {
                    contents_begin,
                    contents_end,
                    ..
                }
                | Element::Italic {
                    contents_begin,
                    contents_end,
                    ..
                }
                | Element::Strike {
                    contents_begin,
                    contents_end,
                    ..
                } => {
                    self.parse_objects_children(contents_begin, contents_end, node);
                }
                Element::List {
                    list: List { indent, .. },
                    contents_begin,
                    contents_end,
                    ..
                } => {
                    self.parse_list_items(contents_begin, contents_end, indent, node);
                }
                _ => (),
            }

            if let Some(next_node) = self.next_node(node) {
                node = next_node;
            } else {
                break;
            }
        }
    }

    fn next_node(&self, mut node: NodeId) -> Option<NodeId> {
        if let Some(child) = self.arena[node].first_child() {
            return Some(child);
        }

        loop {
            if let Some(sibling) = self.arena[node].next_sibling() {
                return Some(sibling);
            } else if let Some(parent) = self.arena[node].parent() {
                node = parent;
            } else {
                return None;
            }
        }
    }

    fn parse_elements_children(&mut self, mut begin: usize, end: usize, node: NodeId) {
        'out: while begin < end {
            let text = &self.text[begin..end];
            let mut pos = 0;
            for i in memchr_iter(b'\n', text.as_bytes()) {
                if text.as_bytes()[pos..i].iter().all(u8::is_ascii_whitespace) {
                    let (end, _) = skip_empty_lines(&text[i..]);
                    let new_node = self.arena.new_node(Element::Paragraph {
                        begin,
                        end: begin + i + end,
                        contents_begin: begin,
                        contents_end: begin + pos,
                    });
                    node.append(new_node, &mut self.arena).unwrap();
                    begin += i + end;
                    continue 'out;
                } else if let Some((ty, off)) = self.parse_element(begin + pos, end) {
                    let new_node = self.arena.new_node(Element::Paragraph {
                        begin,
                        end: begin + pos,
                        contents_begin: begin,
                        contents_end: begin + pos,
                    });
                    node.append(new_node, &mut self.arena).unwrap();
                    let new_node = self.arena.new_node(ty);
                    node.append(new_node, &mut self.arena).unwrap();
                    begin += pos + off;
                    continue 'out;
                }
                pos = i + 1;
            }

            let new_node = self.arena.new_node(Element::Paragraph {
                begin,
                end,
                contents_begin: begin,
                contents_end: if text.ends_with('\n') { end - 1 } else { end },
            });
            begin = end;
            node.append(new_node, &mut self.arena).unwrap();
        }
    }

    fn parse_element(&self, begin: usize, end: usize) -> Option<(Element<'a>, usize)> {
        let text = &self.text[begin..end];

        if let Some((fn_def, off, end)) = FnDef::parse(text) {
            let fn_def = Element::FnDef {
                begin,
                end: begin + end,
                contents_begin: begin + off,
                contents_end: begin + end,
                fn_def,
            };
            return Some((fn_def, end));
        } else if let Some((list, limit, end)) = List::parse(text) {
            let list = Element::List {
                list,
                begin,
                end: begin + end,
                contents_begin: begin,
                contents_end: begin + limit,
            };
            return Some((list, end));
        }

        let line_begin = text.find(|c: char| !c.is_ascii_whitespace()).unwrap_or(0);
        let tail = &text[line_begin..];

        if let Some((clock, end)) = Clock::parse(tail) {
            let clock = Element::Clock {
                clock,
                begin,
                end: begin + line_begin + end,
            };
            return Some((clock, line_begin + end));
        }

        // TODO: LaTeX environment
        if tail.starts_with("\\begin{") {}

        // rule
        if tail.starts_with("-----") {
            if let Some(end) = Rule::parse(tail) {
                let rule = Element::Rule {
                    begin,
                    end: begin + line_begin + end,
                };
                return Some((rule, line_begin + end));
            }
        }

        if tail.starts_with(':') {
            if let Some((drawer, off, limit, end)) = Drawer::parse(tail) {
                let drawer = Element::Drawer {
                    drawer,
                    begin,
                    end: begin + line_begin + end,
                    contents_begin: begin + line_begin + off,
                    contents_end: begin + line_begin + limit,
                };
                return Some((drawer, line_begin + end));
            }
        }

        // fixed width
        if tail.starts_with(": ") || tail.starts_with(":\n") {
            // let end = line_ends
            //     .skip_while(|&i| {
            //         text[i + 1..].starts_with(": ") || text[i + 1..].starts_with(":\n")
            //     })
            //     .next()
            //     .map(|i| i + 1)
            //     .unwrap_or_else(|| text.len());
            // let off = end - pos;
            // brk!(Element::FixedWidth(&tail[0..off]), off);
        }

        // comment
        if tail.starts_with("# ") || tail.starts_with("#\n") {
            // let end = line_ends
            //     .skip_while(|&i| {
            //         text[i + 1..].starts_with("# ") || text[i + 1..].starts_with("#\n")
            //     })
            //     .next()
            //     .map(|i| i + 1)
            //     .unwrap_or_else(|| text.len());
            // let off = end - pos;
            // brk!(Element::Comment(&tail[0..off]), off);
        }

        if tail.starts_with("#+") {
            if let Some((block, off, limit, end)) = Block::parse(tail) {
                let block = Element::Block {
                    block,
                    begin,
                    end: begin + line_begin + end,
                    contents_begin: begin + line_begin + off,
                    contents_end: begin + line_begin + limit,
                };
                return Some((block, line_begin + end));
            } else if let Some((dyn_block, off, limit, end)) = DynBlock::parse(tail) {
                let dyn_block = Element::DynBlock {
                    dyn_block,
                    begin,
                    end: begin + line_begin + end,
                    contents_begin: begin + line_begin + off,
                    contents_end: begin + line_begin + limit,
                };
                return Some((dyn_block, line_begin + end));
            } else if let Some((key, option, value, end)) = Keyword::parse(tail) {
                if key.eq_ignore_ascii_case("CALL") {
                    let call = Element::BabelCall {
                        value,
                        begin,
                        end: begin + line_begin + end,
                    };
                    return Some((call, line_begin + end));
                } else {
                    let kw = Element::Keyword {
                        keyword: Keyword { key, option, value },
                        begin,
                        end: begin + line_begin + end,
                    };
                    return Some((kw, line_begin + end));
                }
            }
        }

        None
    }

    fn parse_objects_children(&mut self, mut begin: usize, end: usize, node: NodeId) {
        'out: while begin < end {
            let bytes = self.text[begin..end].as_bytes();

            match bytes[0] {
                b'{' | b' ' | b'"' | b',' | b'(' | b'\n' => {
                    if let Some((ty, off)) = self.parse_object(begin + 1, end) {
                        let new_node = self.arena.new_node(Element::Text {
                            value: &self.text[begin..=begin],
                            begin,
                            end,
                        });
                        node.append(new_node, &mut self.arena).unwrap();
                        let new_node = self.arena.new_node(ty);
                        node.append(new_node, &mut self.arena).unwrap();
                        begin += 1 + off;
                        continue;
                    }
                }
                _ => {
                    if let Some((ty, off)) = self.parse_object(begin, end) {
                        let new_node = self.arena.new_node(ty);
                        node.append(new_node, &mut self.arena).unwrap();
                        begin += off;
                        continue;
                    }
                }
            }

            let bs = bytes!(b'@', b' ', b'"', b'(', b'\n', b'{', b'<', b'[');
            let mut pos = 0;
            while let Some(off) = bs.find(&bytes[pos..]) {
                pos += off;
                assert!(begin + pos <= end);
                match bytes[pos] {
                    b'{' | b' ' | b'"' | b',' | b'(' | b'\n' => {
                        if let Some((ty, off)) = self.parse_object(begin + pos + 1, end) {
                            let new_node = self.arena.new_node(Element::Text {
                                value: &self.text[begin..=begin + pos],
                                begin,
                                end,
                            });
                            node.append(new_node, &mut self.arena).unwrap();
                            let new_node = self.arena.new_node(ty);
                            node.append(new_node, &mut self.arena).unwrap();
                            begin += pos + 1 + off;
                            continue 'out;
                        }
                    }
                    _ => {
                        if let Some((ty, off)) = self.parse_object(begin + pos, end) {
                            let new_node = self.arena.new_node(Element::Text {
                                value: &self.text[begin..begin + pos],
                                begin,
                                end,
                            });
                            node.append(new_node, &mut self.arena).unwrap();
                            let new_node = self.arena.new_node(ty);
                            node.append(new_node, &mut self.arena).unwrap();
                            begin += pos + off;
                            continue 'out;
                        }
                    }
                }
                pos += 1;
            }

            let new_node = self.arena.new_node(Element::Text {
                value: &self.text[begin..end],
                begin,
                end,
            });
            node.append(new_node, &mut self.arena).unwrap();
            begin = end;
        }
    }

    fn parse_object(&self, begin: usize, end: usize) -> Option<(Element<'a>, usize)> {
        let text = &self.text[begin..end];
        if text.len() < 3 {
            None
        } else {
            let bytes = text.as_bytes();
            match bytes[0] {
                b'@' if bytes[1] == b'@' => Snippet::parse(text).map(|(snippet, off)| {
                    (
                        Element::Snippet {
                            snippet,
                            begin,
                            end: begin + off,
                        },
                        off,
                    )
                }),
                b'{' if bytes[1] == b'{' && bytes[2] == b'{' => {
                    Macros::parse(text).map(|(macros, off)| {
                        (
                            Element::Macros {
                                macros,
                                begin,
                                end: begin + off,
                            },
                            off,
                        )
                    })
                }
                b'<' if bytes[1] == b'<' => {
                    if bytes[2] == b'<' {
                        RadioTarget::parse(text).map(|(radio_target, off)| {
                            (
                                Element::RadioTarget {
                                    radio_target,
                                    begin,
                                    end: begin + off,
                                },
                                off,
                            )
                        })
                    } else {
                        Target::parse(text).map(|(target, off)| {
                            (
                                Element::Target {
                                    target,
                                    begin,
                                    end: begin + off,
                                },
                                off,
                            )
                        })
                    }
                }
                b'<' => Timestamp::parse_active(text)
                    .or_else(|| (Timestamp::parse_diary(text)))
                    .map(|(timestamp, off)| {
                        (
                            Element::Timestamp {
                                timestamp,
                                begin,
                                end: begin + off,
                            },
                            off,
                        )
                    }),
                b'[' => {
                    if text[1..].starts_with("fn:") {
                        FnRef::parse(text).map(|(fn_ref, off)| {
                            (
                                Element::FnRef {
                                    fn_ref,
                                    begin,
                                    end: begin + off,
                                },
                                off,
                            )
                        })
                    } else if bytes[1] == b'[' {
                        Link::parse(text).map(|(link, off)| {
                            (
                                Element::Link {
                                    link,
                                    begin,
                                    end: begin + off,
                                },
                                off,
                            )
                        })
                    } else {
                        Cookie::parse(text)
                            .map(|(cookie, off)| {
                                (
                                    Element::Cookie {
                                        cookie,
                                        begin,
                                        end: begin + off,
                                    },
                                    off,
                                )
                            })
                            .or_else(|| {
                                Timestamp::parse_inactive(text).map(|(timestamp, off)| {
                                    (
                                        Element::Timestamp {
                                            timestamp,
                                            begin,
                                            end: begin + off,
                                        },
                                        off,
                                    )
                                })
                            })
                    }
                }
                b'*' => emphasis::parse(text, b'*').map(|off| {
                    (
                        Element::Bold {
                            begin,
                            contents_begin: begin + 1,
                            contents_end: begin + off - 1,
                            end: begin + off,
                        },
                        off,
                    )
                }),
                b'+' => emphasis::parse(text, b'+').map(|off| {
                    (
                        Element::Strike {
                            begin,
                            contents_begin: begin + 1,
                            contents_end: begin + off - 1,
                            end: begin + off,
                        },
                        off,
                    )
                }),
                b'/' => emphasis::parse(text, b'/').map(|off| {
                    (
                        Element::Italic {
                            begin,
                            contents_begin: begin + 1,
                            contents_end: begin + off - 1,
                            end: begin + off,
                        },
                        off,
                    )
                }),
                b'_' => emphasis::parse(text, b'_').map(|off| {
                    (
                        Element::Underline {
                            begin,
                            contents_begin: begin + 1,
                            contents_end: begin + off - 1,
                            end: begin + off,
                        },
                        off,
                    )
                }),
                b'=' => emphasis::parse(text, b'=').map(|off| {
                    (
                        Element::Verbatim {
                            begin,
                            end: begin + off,
                            value: &text[1..off - 1],
                        },
                        off,
                    )
                }),
                b'~' => emphasis::parse(text, b'~').map(|off| {
                    (
                        Element::Code {
                            begin,
                            end: begin + off,
                            value: &text[1..off - 1],
                        },
                        off,
                    )
                }),
                b's' if text.starts_with("src_") => {
                    InlineSrc::parse(text).map(|(inline_src, off)| {
                        (
                            Element::InlineSrc {
                                inline_src,
                                begin,
                                end: begin + off,
                            },
                            off,
                        )
                    })
                }
                b'c' if text.starts_with("call_") => {
                    InlineCall::parse(text).map(|(inline_call, off)| {
                        (
                            Element::InlineCall {
                                inline_call,
                                begin,
                                end: begin + off,
                            },
                            off,
                        )
                    })
                }
                _ => None,
            }
        }
    }

    fn parse_list_items(&mut self, mut begin: usize, end: usize, indent: usize, node: NodeId) {
        while begin < end {
            let text = &self.text[begin..end];
            let (list_item, off, end) = ListItem::parse(text, indent);
            let list_item = Element::ListItem {
                list_item,
                begin,
                end: begin + end,
                contents_begin: begin + off,
                contents_end: begin + end,
            };
            let new_node = self.arena.new_node(list_item);
            node.append(new_node, &mut self.arena).unwrap();
            begin += end;
        }
    }
}

fn skip_empty_lines(text: &str) -> (usize, usize) {
    let mut i = 0;
    let mut j = text.len();
    for pos in memchr_iter(b'\n', text.as_bytes()) {
        if text.as_bytes()[i..pos].iter().all(u8::is_ascii_whitespace) {
            i = pos + 1;
        } else {
            break;
        }
    }

    for pos in memrchr_iter(b'\n', text.as_bytes()) {
        if text.as_bytes()[pos..j].iter().all(u8::is_ascii_whitespace) {
            j = pos;
        } else {
            break;
        }
    }

    (i, j)
}