use crate::kinds::SyntaxKind::*;
use rowan::{ast::AstNode as OtherAstNode, NodeOrToken};

use crate::ast;

use super::{support::children_tokens_u, AstToken, InterpolPart, StrContent};

impl ast::Str {
    pub fn parts(&self) -> impl Iterator<Item = InterpolPart<StrContent>> {
        self.syntax().children_with_tokens().filter_map(|child| match child {
            NodeOrToken::Token(token) if token.kind() == TOKEN_STRING_CONTENT => {
                Some(InterpolPart::Literal(StrContent::cast(token).unwrap()))
            }
            NodeOrToken::Token(token) => {
                assert!(token.kind() == TOKEN_STRING_START || token.kind() == TOKEN_STRING_END);
                None
            }
            NodeOrToken::Node(node) => {
                assert_eq!(node.kind(), NODE_INTERPOL);
                Some(InterpolPart::Interpolation(ast::Interpol::cast(node).unwrap()))
            }
        })
    }

    pub fn normalized_parts(&self) -> Vec<InterpolPart<String>> {
        let multiline = children_tokens_u(self).next().is_some_and(|t| t.text() == "''");
        let mut is_first_literal = true;
        let mut at_start_of_line = true;
        let mut min_indent = 1000000;
        let mut cur_indent = 0;
        let mut n = 0;
        let mut first_is_literal = false;

        let parts: Vec<InterpolPart<StrContent>> = self.parts().collect();

        if multiline {
            for part in &parts {
                match part {
                    InterpolPart::Interpolation(_) => {
                        if at_start_of_line {
                            at_start_of_line = false;
                            min_indent = min_indent.min(cur_indent);
                        }
                        n += 1;
                    }
                    InterpolPart::Literal(literal) => {
                        let mut token_text = literal.syntax().text();

                        if n == 0 {
                            first_is_literal = true;
                        }

                        if is_first_literal && first_is_literal {
                            is_first_literal = false;
                            if let Some(p) = token_text.find('\n') {
                                if token_text[0..p].chars().all(|c| c == ' ') {
                                    token_text = &token_text[p + 1..]
                                }
                            }
                        }

                        for c in token_text.chars() {
                            if at_start_of_line {
                                if c == ' ' {
                                    cur_indent += 1;
                                } else if c == '\n' {
                                    cur_indent = 0;
                                } else {
                                    at_start_of_line = false;
                                    min_indent = min_indent.min(cur_indent);
                                }
                            } else if c == '\n' {
                                at_start_of_line = true;
                                cur_indent = 0;
                            }
                        }

                        n += 1;
                    }
                }
            }
        }

        let mut normalized_parts = Vec::new();
        let mut cur_dropped = 0;
        let mut i = 0;
        is_first_literal = true;
        at_start_of_line = true;

        for part in parts {
            match part {
                InterpolPart::Interpolation(interpol) => {
                    at_start_of_line = false;
                    cur_dropped = 0;
                    normalized_parts.push(InterpolPart::Interpolation(interpol));
                    i += 1;
                }
                InterpolPart::Literal(literal) => {
                    let mut token_text = literal.syntax().text();

                    if multiline {
                        if is_first_literal && first_is_literal {
                            is_first_literal = false;
                            if let Some(p) = token_text.find('\n') {
                                if token_text[0..p].chars().all(|c| c == ' ') {
                                    token_text = &token_text[p + 1..];
                                    if token_text.is_empty() {
                                        i += 1;
                                        continue;
                                    }
                                }
                            }
                        }

                        let mut str = String::new();
                        for c in token_text.chars() {
                            if at_start_of_line {
                                if c == ' ' {
                                    if cur_dropped >= min_indent {
                                        str.push(c);
                                    }
                                    cur_dropped += 1;
                                } else if c == '\n' {
                                    cur_dropped = 0;
                                    str.push(c);
                                } else {
                                    at_start_of_line = false;
                                    cur_dropped = 0;
                                    str.push(c);
                                }
                            } else {
                                str.push(c);
                                if c == '\n' {
                                    at_start_of_line = true;
                                }
                            }
                        }

                        if i == n - 1 {
                            if let Some(p) = str.rfind('\n') {
                                if str[p + 1..].chars().all(|c| c == ' ') {
                                    str.truncate(p + 1);
                                }
                            }
                        }

                        normalized_parts.push(InterpolPart::Literal(unescape(&str, multiline)));
                        i += 1;
                    } else {
                        normalized_parts
                            .push(InterpolPart::Literal(unescape(token_text, multiline)));
                    }
                }
            }
        }

        normalized_parts
    }
}

/// Interpret escape sequences in the nix string and return the converted value
pub fn unescape(input: &str, multiline: bool) -> String {
    let mut output = String::new();
    let mut input = input.chars().peekable();
    loop {
        match input.next() {
            None => break,
            Some('"') if !multiline => break,
            Some('\\') if !multiline => match input.next() {
                None => break,
                Some('n') => output.push('\n'),
                Some('r') => output.push('\r'),
                Some('t') => output.push('\t'),
                Some(c) => output.push(c),
            },
            Some('\'') if multiline => match input.next() {
                None => {
                    output.push('\'');
                }
                Some('\'') => match input.peek() {
                    Some('\'') => {
                        input.next().unwrap();
                        output.push_str("''");
                    }
                    Some('$') => {
                        input.next().unwrap();
                        output.push('$');
                    }
                    Some('\\') => {
                        input.next().unwrap();
                        match input.next() {
                            None => break,
                            Some('n') => output.push('\n'),
                            Some('r') => output.push('\r'),
                            Some('t') => output.push('\t'),
                            Some(c) => output.push(c),
                        }
                    }
                    _ => break,
                },
                Some(c) => {
                    output.push('\'');
                    output.push(c);
                }
            },
            Some(c) => output.push(c),
        }
    }
    output
}

#[cfg(test)]
mod tests {
    use crate::Root;

    use super::*;

    #[test]
    fn string_unescapes() {
        assert_eq!(unescape(r#"Hello\n\"World\" :D"#, false), "Hello\n\"World\" :D");
        assert_eq!(unescape(r#"\"Hello\""#, false), "\"Hello\"");

        assert_eq!(unescape(r#"Hello''\n'''World''' :D"#, true), "Hello\n''World'' :D");
        assert_eq!(unescape(r#""Hello""#, true), "\"Hello\"");
    }
    #[test]
    fn parts_leading_ws() {
        let inp = "''\n  hello\n  world''";
        let expr = Root::parse(inp).ok().unwrap().expr().unwrap();
        match expr {
            ast::Expr::Str(str) => {
                assert_eq!(
                    str.normalized_parts(),
                    vec![InterpolPart::Literal("hello\nworld".to_string())]
                )
            }
            _ => unreachable!(),
        }
    }
    #[test]
    fn parts_trailing_ws_single_line() {
        let inp = "''hello ''";
        let expr = Root::parse(inp).ok().unwrap().expr().unwrap();
        match expr {
            ast::Expr::Str(str) => {
                assert_eq!(
                    str.normalized_parts(),
                    vec![InterpolPart::Literal("hello ".to_string())]
                )
            }
            _ => unreachable!(),
        }
    }
    #[test]
    fn parts_trailing_ws_multiline() {
        let inp = "''hello\n ''";
        let expr = Root::parse(inp).ok().unwrap().expr().unwrap();
        match expr {
            ast::Expr::Str(str) => {
                assert_eq!(
                    str.normalized_parts(),
                    vec![InterpolPart::Literal("hello\n".to_string())]
                )
            }
            _ => unreachable!(),
        }
    }
    #[test]
    fn parts() {
        use crate::{NixLanguage, SyntaxNode};
        use rowan::{GreenNodeBuilder, Language};

        fn string_node(content: &str) -> ast::Str {
            let mut builder = GreenNodeBuilder::new();
            builder.start_node(NixLanguage::kind_to_raw(NODE_STRING));
            builder.token(NixLanguage::kind_to_raw(TOKEN_STRING_START), "''");
            builder.token(NixLanguage::kind_to_raw(TOKEN_STRING_CONTENT), content);
            builder.token(NixLanguage::kind_to_raw(TOKEN_STRING_END), "''");
            builder.finish_node();

            ast::Str::cast(SyntaxNode::new_root(builder.finish())).unwrap()
        }

        let txtin = r#"
                        |trailing-whitespace
                              |trailing-whitespace
                    This is a multiline string :D
                      indented by two
                    \'\'\'\'\
                    ''${ interpolation was escaped }
                    two single quotes: '''
                    three single quotes: ''''
                "#
        .replace("|trailing-whitespace", "");

        if let [InterpolPart::Literal(lit)] =
            &ast::Str::normalized_parts(&string_node(txtin.as_str()))[..]
        {
            assert_eq!(lit,
                // Get the below with nix repl
                "    \n          \nThis is a multiline string :D\n  indented by two\n\\'\\'\\'\\'\\\n${ interpolation was escaped }\ntwo single quotes: ''\nthree single quotes: '''\n"
            );
        } else {
            unreachable!();
        }
    }

    #[test]
    fn parts_ast() {
        fn assert_eq_ast_ctn(it: &mut dyn Iterator<Item = InterpolPart<String>>, x: &str) {
            let tmp = it.next().expect("unexpected EOF");
            if let InterpolPart::Interpolation(astn) = tmp {
                assert_eq!(astn.expr().unwrap().syntax().to_string(), x);
            } else {
                unreachable!("unexpected literal {:?}", tmp);
            }
        }

        let inp = r#"''

        This version of Nixpkgs requires Nix >= ${requiredVersion}, please upgrade:

        - If you are running NixOS, `nixos-rebuild' can be used to upgrade your system.

        - Alternatively, with Nix > 2.0 `nix upgrade-nix' can be used to imperatively
          upgrade Nix. You may use `nix-env --version' to check which version you have.

        - If you installed Nix using the install script (https://nixos.org/nix/install),
          it is safe to upgrade by running it again:

              curl -L https://nixos.org/nix/install | sh

        For more information, please see the NixOS release notes at
        https://nixos.org/nixos/manual or locally at
        ${toString ./nixos/doc/manual/release-notes}.

        If you need further help, see https://nixos.org/nixos/support.html
      ''"#;
        let expr = Root::parse(inp).ok().unwrap().expr().unwrap();
        match expr {
            ast::Expr::Str(s) => {
                let mut it = s.normalized_parts().into_iter();
                assert_eq!(
                    it.next().unwrap(),
                    InterpolPart::Literal("\nThis version of Nixpkgs requires Nix >= ".to_string())
                );
                assert_eq_ast_ctn(&mut it, "requiredVersion");
                assert_eq!(it.next().unwrap(), InterpolPart::Literal(
                        ", please upgrade:\n\n- If you are running NixOS, `nixos-rebuild' can be used to upgrade your system.\n\n- Alternatively, with Nix > 2.0 `nix upgrade-nix' can be used to imperatively\n  upgrade Nix. You may use `nix-env --version' to check which version you have.\n\n- If you installed Nix using the install script (https://nixos.org/nix/install),\n  it is safe to upgrade by running it again:\n\n      curl -L https://nixos.org/nix/install | sh\n\nFor more information, please see the NixOS release notes at\nhttps://nixos.org/nixos/manual or locally at\n".to_string()
                    ));
                assert_eq_ast_ctn(&mut it, "toString ./nixos/doc/manual/release-notes");
                assert_eq!(
                    it.next().unwrap(),
                    InterpolPart::Literal(
                        ".\n\nIf you need further help, see https://nixos.org/nixos/support.html\n"
                            .to_string()
                    )
                );
            }
            _ => unreachable!(),
        }
    }
}