use crate::config::{Config, FiletypeConfig};
use clap::{crate_version, App, Arg};
use serde::Deserialize;
use std::io::Read;
use toml;
use tree_sitter::{Node, Parser, Range};

mod config;
mod ffi;
mod kakoune;
mod tree;

#[derive(Deserialize, Debug)]
struct Request {
    op: Op,
    filetype: String,
    selections_desc: String,
    content: String,
}

#[derive(Deserialize, Debug)]
#[serde(tag = "type")]
enum Op {
    NodeSExp,
    HighlightCurrentNode,
    SelectChildren { kind: Option<String> },
    SelectNextNode { kind: Option<String> },
    SelectParentNode { kind: Option<String> },
    SelectPreviousNode { kind: Option<String> },
    SelectNode,
}

fn main() {
    let matches = cli();

    if let Some(filetype) = matches.value_of("do-you-understand") {
        let language = ffi::filetype_to_language(filetype);
        if let Some(language) = language {
            eprintln!("Known language. Trying to load");
            let mut parser = Parser::new();
            parser.set_language(language).unwrap();
            eprintln!("Loaded successfully");
            std::process::exit(0);
        } else {
            eprintln!("Unknown language");
            std::process::exit(1);
        }
    }

    let config = if let Some(config_path) = matches.value_of("config") {
        Config::load(config_path).unwrap()
    } else {
        Config::default()
    };

    let mut request = String::new();
    std::io::stdin().read_to_string(&mut request).unwrap();
    let request: Request = toml::from_str(&request).unwrap();
    let response = handle_request(&config, &request);
    eprintln!("(request: {:?})", request);
    println!("{}", response);
}

fn cli() -> clap::ArgMatches<'static> {
    App::new("kak-tree")
        .version(crate_version!())
        .author("Ruslan Prokopchuk <fer.obbee@gmail.com>")
        .about("Structural selections for Kakoune")
        .arg(
            Arg::with_name("config")
                .short("c")
                .long("config")
                .value_name("FILE")
                .help("Read config from FILE")
                .takes_value(true),
        )
        .arg(
            Arg::with_name("do-you-understand")
                .long("do-you-understand")
                .value_name("FILETYPE")
                .help("Exit with 0 if FILETYPE is supported, non-zero otherwise")
                .takes_value(true),
        )
        .arg(
            Arg::with_name("v")
                .short("v")
                .multiple(true)
                .help("Sets the level of verbosity"),
        )
        .get_matches()
}

fn handle_request(config: &Config, request: &Request) -> String {
    let mut parser = Parser::new();
    let language = ffi::filetype_to_language(&request.filetype).unwrap();
    parser.set_language(language).unwrap();
    let tree = parser.parse(&request.content, None).unwrap();
    let buffer = request
        .content
        .split('\n')
        .map(|s| format!("{}\n", s))
        .collect::<Vec<_>>();
    let ranges = kakoune::selections_desc_to_ranges(&buffer, &request.selections_desc);
    let mut new_ranges = Vec::new();
    let filetype_config = config.get_filetype_config(&request.filetype);
    match &request.op {
        Op::SelectNode => {
            for range in &ranges {
                let node = tree::shrink_to_range(tree.root_node(), range);
                new_ranges.push(node.range());
            }
            kakoune::select_ranges(&buffer, &new_ranges)
        }
        Op::SelectParentNode { kind } => {
            let kinds = kind
                .as_ref()
                .and_then(|kind| Some(filetype_config.resolve_alias(kind)));
            for range in &ranges {
                let node = tree::shrink_to_range(tree.root_node(), range);
                let node = find_parent_of_interest(filetype_config, node, &kinds);
                new_ranges.push(node.range());
            }
            kakoune::select_ranges(&buffer, &new_ranges)
        }
        Op::SelectNextNode { kind } | Op::SelectPreviousNode { kind } => {
            let kinds = kind
                .as_ref()
                .and_then(|kind| Some(filetype_config.resolve_alias(kind)));
            'outer_next: for range in &ranges {
                let node = tree::shrink_to_range(tree.root_node(), range);
                let mut cursor = node;
                loop {
                    let parent = cursor.parent();
                    loop {
                        if filetype_config.is_node_visible(cursor) && node_of_kinds(cursor, &kinds) {
                            if cursor != node {
                                new_ranges.push(cursor.range());
                                continue 'outer_next;
                            }
                        }
                        if let Op::SelectNextNode { .. } = request.op {
                            if let Some(next) = cursor.next_named_sibling() {
                                cursor = next;
                            } else {
                                break;
                            }
                        } else {
                            if let Some(prev) = cursor.prev_named_sibling() {
                                cursor = prev;
                            } else {
                                break;
                            }
                        }
                    }
                    if let Some(parent) = parent {
                        cursor = parent;
                    } else {
                        break;
                    }
                }
                // TODO: Do we want this behaviour?
                // let node = find_parent_of_interest(filetype_config, node, &kinds);
                // new_ranges.push(node.range());
            }
            kakoune::select_ranges(&buffer, &new_ranges)
        }
        Op::SelectChildren { kind } => {
            match kind {
                Some(kind) => {
                    let kinds = filetype_config.resolve_alias(kind);
                    for range in &ranges {
                        let node = tree::shrink_to_range(tree.root_node(), range);
                        select_nodes(&node, &kinds, &mut new_ranges);
                    }
                }
                None => {
                    for range in &ranges {
                        let node = tree::shrink_to_range(tree.root_node(), range);
                        for child in tree::named_children(&node) {
                            if filetype_config.is_node_visible(child) {
                                new_ranges.push(child.range());
                            }
                        }
                    }
                }
            }
            kakoune::select_ranges(&buffer, &new_ranges)
        }
        Op::NodeSExp => {
            let node = tree::shrink_to_range(tree.root_node(), &ranges[0]);
            format!("info '{}'", node.to_sexp())
        }
        Op::HighlightCurrentNode => {
            for range in &ranges {
                let node = tree::shrink_to_range(tree.root_node(), range);
                new_ranges.push(node.range());
            }
            kakoune::highlight_ranges(&buffer, &new_ranges)
        }
    }
}

fn select_nodes(node: &Node, kinds: &[String], new_ranges: &mut Vec<Range>) {
    for child in tree::named_children(&node) {
        if kinds.iter().any(|kind| kind == child.kind()) {
            new_ranges.push(child.range());
        } else {
            select_nodes(&child, kinds, new_ranges);
        }
    }
}

fn traverse_up_to_node_which_matters<'a>(
    filetype_config: &FiletypeConfig,
    current_node: Node<'a>,
) -> Node<'a> {
    let mut opt_node = Some(current_node);
    while let Some(node) = opt_node.filter(|&n| !(n.is_named() && filetype_config.is_node_visible(n))) {
        opt_node = node.parent();
    }
    opt_node.unwrap_or(current_node)
}

fn find_parent_of_interest<'a>(
    filetype_config: &FiletypeConfig,
    current_node: Node<'a>,
    kinds: &Option<Vec<String>>,
) -> Node<'a> {
    let parent = current_node.parent();
    match &kinds {
        Some(kinds) => {
            let mut cursor = parent;
            while let Some(node) = cursor {
                if kinds.iter().any(|kind| kind == node.kind()) {
                    return node;
                }
                cursor = node.parent();
            }
            current_node
        }
        None => traverse_up_to_node_which_matters(filetype_config, parent.unwrap_or(current_node)),
    }
}

fn node_of_kinds(node: Node, kinds: &Option<Vec<String>>) -> bool {
    kinds
        .as_ref()
        .and_then(|kinds| Some(kinds.iter().any(|x| x == node.kind())))
        .unwrap_or(true)
}