/*

 * Hurl (https://hurl.dev)

 * Copyright (C) 2024 Orange

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *          http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 *

 */

use crate::ast::*;

use crate::combinator::{one_or_more, optional, recover, zero_or_more};

use crate::parser::error::*;

use crate::parser::string::*;

use crate::parser::{base64, filename, key_string, ParseResult};

use crate::reader::Reader;

            } else {

            }

        }

    }

}

        }

    }

}

        //Ok(v) => return Ok(v.join("")),

        }

    }

}

    // let start = p.state.clone();

        }

    } else {

            }

        }

    };

}

}

    loop {

        }

            Ok(_) => {

            }

            _ => {

                }

            }

        }

    }

}

/// Does not return a value, non recoverable parser. Use combinator recover to make it recoverable

            None => {

            }

                } else {

                }

            }

        }

    }

}

/// Recoverable version which reset the cursor, meant to be combined with following action.

        }

    }

}

/// Returns the literal string

        Err(_) => {

                Err(_) => {

                }

            }

        }

    }

}

            Err(_) => {

            }

        },

    }

}

}

    loop {

                }

            }

            Err(_) => {

            }

    }

    }

}

    // Hurl escaping /

    // in order to avoid terminating the regex

    // eg. \a\b/

    //

    // Other escaped sequences such as \* are part of the regex expression

    // They are not part of the syntax of Hurl itself.

    loop {

            None => {

            }

            Some('\\') => {

                }

            }

        }

    }

                }

            };

        }

    }

}

}

            Err(_) => {

            }

        },

    }

}

}

}

    } else {

    }

}

    }

}

        },

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::reader::Pos;

    #[test]

    fn test_space() {

        let mut reader = Reader::new("x");

        let error = space(&mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 1 });

        assert_eq!(reader.cursor().index, 1);

        let mut reader = Reader::new("  ");

        assert_eq!(

            space(&mut reader),

            Ok(Whitespace {

                value: " ".to_string(),

                source_info: SourceInfo::new(Pos::new(1, 1), Pos::new(1, 2)),

            }),

        );

        assert_eq!(reader.cursor().index, 1);

    }

    #[test]

    fn test_one_or_more_spaces() {

        let mut reader = Reader::new("  ");

        assert_eq!(

            one_or_more_spaces(&mut reader),

            Ok(Whitespace {

                value: "  ".to_string(),

                source_info: SourceInfo::new(Pos::new(1, 1), Pos::new(1, 3)),

            })

        );

        let mut reader = Reader::new("abc");

        let error = one_or_more_spaces(&mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 1 });

    }

    #[test]

    fn test_zero_or_more_spaces() {

        let mut reader = Reader::new("  ");

        assert_eq!(

            zero_or_more_spaces(&mut reader),

            Ok(Whitespace {

                value: "  ".to_string(),

                source_info: SourceInfo::new(Pos::new(1, 1), Pos::new(1, 3)),

            })

        );

        assert_eq!(reader.cursor().index, 2);

        let mut reader = Reader::new("xxx");

        assert_eq!(

            zero_or_more_spaces(&mut reader),

            Ok(Whitespace {

                value: String::new(),

                source_info: SourceInfo::new(Pos::new(1, 1), Pos::new(1, 1)),

            })

        );

        assert_eq!(reader.cursor().index, 0);

        let mut reader = Reader::new(" xxx");

        assert_eq!(

            zero_or_more_spaces(&mut reader),

            Ok(Whitespace {

                value: " ".to_string(),

                source_info: SourceInfo::new(Pos::new(1, 1), Pos::new(1, 2)),

            })

        );

        assert_eq!(reader.cursor().index, 1);

    }

    #[test]

    fn test_comment() {

        //    let mut parser = Parser::init("# comment");

        //    assert_eq!(

        //        comment(&mut reader),

        //        Ok(Comment {

        //            value: " comment".to_string()

        //        })

        //    );

        //    assert_eq!(reader.state.cursor, 9);

        let mut reader = Reader::new("#\n");

        assert_eq!(

            comment(&mut reader),

            Ok(Comment {

                value: String::new(),

                source_info: SourceInfo::new(Pos::new(1, 2), Pos::new(1, 2)),

            })

        );

        let mut reader = Reader::new("# comment\n");

        assert_eq!(

            comment(&mut reader),

            Ok(Comment {

                value: " comment".to_string(),

                source_info: SourceInfo::new(Pos::new(1, 2), Pos::new(1, 10)),

            })

        );

        assert_eq!(reader.cursor().index, 9);

        let mut reader = Reader::new("xxx");

        let error = comment(&mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 1 });

        assert!(error.recoverable);

    }

    #[test]

    fn test_literal() {

        let mut reader = Reader::new("hello");

        assert_eq!(literal("hello", &mut reader), Ok(()));

        assert_eq!(reader.cursor().index, 5);

        let mut reader = Reader::new("");

        let error = literal("hello", &mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 1 });

        assert_eq!(

            error.kind,

            ParseErrorKind::Expecting {

                value: String::from("hello")

            }

        );

        assert_eq!(reader.cursor().index, 0);

        let mut reader = Reader::new("hi");

        let error = literal("hello", &mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 1 });

        assert_eq!(

            error.kind,

            ParseErrorKind::Expecting {

                value: String::from("hello")

            }

        );

        assert_eq!(reader.cursor().index, 2);

        let mut reader = Reader::new("he");

        let error = literal("hello", &mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 1 });

        assert_eq!(

            error.kind,

            ParseErrorKind::Expecting {

                value: String::from("hello")

            }

        );

        assert_eq!(reader.cursor().index, 2);

    }

    #[test]

    fn test_new_line() {

        let mut reader = Reader::new("\n");

        assert_eq!(

            newline(&mut reader).unwrap(),

            Whitespace {

                value: String::from("\n"),

                source_info: SourceInfo::new(Pos::new(1, 1), Pos::new(2, 1)),

            }

        );

    }

    #[test]

    fn test_key_value() {

        let mut reader = Reader::new("message: hello {{name}}! # comment");

        assert_eq!(

            key_value(&mut reader).unwrap(),

            KeyValue {

                line_terminators: vec![],

                space0: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 1), Pos::new(1, 1)),

                },

                key: Template {

                    delimiter: None,

                    elements: vec![TemplateElement::String {

                        value: "message".to_string(),

                        encoded: "message".to_string(),

                    }],

                    source_info: SourceInfo::new(Pos::new(1, 1), Pos::new(1, 8)),

                },

                space1: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 8), Pos::new(1, 8)),

                },

                space2: Whitespace {

                    value: " ".to_string(),

                    source_info: SourceInfo::new(Pos::new(1, 9), Pos::new(1, 10)),

                },

                value: Template {

                    delimiter: None,

                    elements: vec![

                        TemplateElement::String {

                            value: "hello ".to_string(),

                            encoded: "hello ".to_string(),

                        },

                        TemplateElement::Placeholder(Placeholder {

                            space0: Whitespace {

                                value: String::new(),

                                source_info: SourceInfo::new(Pos::new(1, 18), Pos::new(1, 18)),

                            },

                            expr: Expr {

                                kind: ExprKind::Variable(Variable {

                                    name: "name".to_string(),

                                    source_info: SourceInfo::new(Pos::new(1, 18), Pos::new(1, 22)),

                                }),

                                source_info: SourceInfo::new(Pos::new(1, 18), Pos::new(1, 22)),

                            },

                            space1: Whitespace {

                                value: String::new(),

                                source_info: SourceInfo::new(Pos::new(1, 22), Pos::new(1, 22)),

                            },

                        }),

                        TemplateElement::String {

                            value: "!".to_string(),

                            encoded: "!".to_string(),

                        },

                    ],

                    source_info: SourceInfo::new(Pos::new(1, 10), Pos::new(1, 25)),

                },

                line_terminator0: LineTerminator {

                    space0: Whitespace {

                        value: " ".to_string(),

                        source_info: SourceInfo::new(Pos::new(1, 25), Pos::new(1, 26)),

                    },

                    comment: Some(Comment {

                        value: " comment".to_string(),

                        source_info: SourceInfo::new(Pos::new(1, 27), Pos::new(1, 35)),

                    }),

                    newline: Whitespace {

                        value: String::new(),

                        source_info: SourceInfo::new(Pos::new(1, 35), Pos::new(1, 35)),

                    },

                },

            }

        );

    }

    #[test]

    fn test_key_value_template() {

        let mut reader = Reader::new("{{key}}: value");

        assert_eq!(

            key_value(&mut reader).unwrap(),

            KeyValue {

                line_terminators: vec![],

                space0: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 1), Pos::new(1, 1)),

                },

                key: Template {

                    delimiter: None,

                    elements: vec![TemplateElement::Placeholder(Placeholder {

                        space0: Whitespace {

                            value: String::new(),

                            source_info: SourceInfo::new(Pos::new(1, 3), Pos::new(1, 3)),

                        },

                        expr: Expr {

                            kind: ExprKind::Variable(Variable {

                                name: "key".to_string(),

                                source_info: SourceInfo::new(Pos::new(1, 3), Pos::new(1, 6)),

                            }),

                            source_info: SourceInfo::new(Pos::new(1, 3), Pos::new(1, 6))

                        },

                        space1: Whitespace {

                            value: String::new(),

                            source_info: SourceInfo::new(Pos::new(1, 6), Pos::new(1, 6)),

                        },

                    })],

                    source_info: SourceInfo::new(Pos::new(1, 1), Pos::new(1, 8)),

                },

                space1: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 8), Pos::new(1, 8)),

                },

                space2: Whitespace {

                    value: " ".to_string(),

                    source_info: SourceInfo::new(Pos::new(1, 9), Pos::new(1, 10)),

                },

                value: Template {

                    delimiter: None,

                    elements: vec![TemplateElement::String {

                        value: "value".to_string(),

                        encoded: "value".to_string(),

                    }],

                    source_info: SourceInfo::new(Pos::new(1, 10), Pos::new(1, 15)),

                },

                line_terminator0: LineTerminator {

                    space0: Whitespace {

                        value: String::new(),

                        source_info: SourceInfo::new(Pos::new(1, 15), Pos::new(1, 15)),

                    },

                    comment: None,

                    newline: Whitespace {

                        value: String::new(),

                        source_info: SourceInfo::new(Pos::new(1, 15), Pos::new(1, 15)),

                    },

                },

            }

        );

        assert_eq!(reader.cursor().index, 14);

    }

    #[test]

    fn test_key_value_recover() {

        let mut reader = Reader::new("{{key");

        let error = key_value(&mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 6 });

        assert!(error.recoverable);

        assert_eq!(reader.cursor().index, 5); // does not reset cursor

        let mut reader = Reader::new("GET http://google.fr");

        let error = key_value(&mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 5 });

        assert!(error.recoverable);

        assert_eq!(reader.cursor().index, 5); // does not reset cursor

    }

    #[test]

    fn test_boolean() {

        let mut reader = Reader::new("true");

        assert!(boolean(&mut reader).unwrap());

        let mut reader = Reader::new("xxx");

        let error = boolean(&mut reader).err().unwrap();

        assert_eq!(

            error.kind,

            ParseErrorKind::Expecting {

                value: String::from("true|false")

            }

        );

        assert!(error.recoverable);

        let mut reader = Reader::new("trux");

        let error = boolean(&mut reader).err().unwrap();

        assert_eq!(

            error.kind,

            ParseErrorKind::Expecting {

                value: String::from("true|false")

            }

        );

        assert!(error.recoverable);

    }

    #[test]

    fn test_hex_digit() {

        let mut reader = Reader::new("0");

        assert_eq!(hex_digit(&mut reader).unwrap(), 0);

        let mut reader = Reader::new("x");

        let error = hex_digit(&mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 1 });

        assert_eq!(error.kind, ParseErrorKind::HexDigit);

        assert!(error.recoverable);

    }

    #[test]

    fn test_hex() {

        let mut reader = Reader::new("hex, ff;");

        assert_eq!(

            hex(&mut reader).unwrap(),

            Hex {

                space0: Whitespace {

                    value: " ".to_string(),

                    source_info: SourceInfo::new(Pos::new(1, 5), Pos::new(1, 6)),

                },

                value: vec![255],

                encoded: "ff".to_string(),

                space1: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 8), Pos::new(1, 8)),

                },

            }

        );

        let mut reader = Reader::new("hex,010203 ;");

        assert_eq!(

            hex(&mut reader).unwrap(),

            Hex {

                space0: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 5), Pos::new(1, 5)),

                },

                value: vec![1, 2, 3],

                encoded: "010203".to_string(),

                space1: Whitespace {

                    value: " ".to_string(),

                    source_info: SourceInfo::new(Pos::new(1, 11), Pos::new(1, 12)),

                },

            }

        );

    }

    #[test]

    fn test_hex_error() {

        let mut reader = Reader::new("hex,012;");

        let error = hex(&mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 8 });

        assert_eq!(error.kind, ParseErrorKind::OddNumberOfHexDigits);

    }

    #[test]

    fn test_regex() {

        let mut reader = Reader::new(r#"/a{3}/"#);

        assert_eq!(

            regex(&mut reader).unwrap(),

            Regex {

                inner: regex::Regex::new(r#"a{3}"#).unwrap()

            }

        );

        let mut reader = Reader::new(r"/a\/b/");

        assert_eq!(

            regex(&mut reader).unwrap(),

            Regex {

                inner: regex::Regex::new(r#"a/b"#).unwrap()

            }

        );

        let mut reader = Reader::new(r"/a\.b/");

        assert_eq!(

            regex(&mut reader).unwrap(),

            Regex {

                inner: regex::Regex::new(r"a\.b").unwrap()

            }

        );

        let mut reader = Reader::new(r"/\d{4}-\d{2}-\d{2}/");

        assert_eq!(

            regex(&mut reader).unwrap(),

            Regex {

                inner: regex::Regex::new(r"\d{4}-\d{2}-\d{2}").unwrap()

            }

        );

    }

    #[test]

    fn test_regex_error() {

        let mut reader = Reader::new("xxx");

        let error = regex(&mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 1 });

        assert!(error.recoverable);

        let mut reader = Reader::new("/xxx");

        let error = regex(&mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 5 });

        assert!(!error.recoverable);

        assert_eq!(

            error.kind,

            ParseErrorKind::RegexExpr {

                message: "unexpected end of file".to_string()

            }

        );

        let mut reader = Reader::new("/x{a}/");

        let error = regex(&mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 2 });

        assert!(!error.recoverable);

        assert_eq!(

            error.kind,

            ParseErrorKind::RegexExpr {

                message: "repetition quantifier expects a valid decimal".to_string()

            }

        );

    }

    #[test]

    fn test_file() {

        let mut reader = Reader::new("file,data.xml;");

        assert_eq!(

            file(&mut reader).unwrap(),

            File {

                space0: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 6), Pos::new(1, 6)),

                },

                filename: Template {

                    delimiter: None,

                    elements: vec![TemplateElement::String {

                        value: String::from("data.xml"),

                        encoded: String::from("data.xml"),

                    }],

                    source_info: SourceInfo::new(Pos::new(1, 6), Pos::new(1, 14)),

                },

                space1: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 14), Pos::new(1, 14)),

                },

            }

        );

        let mut reader = Reader::new("file, filename1;");

        assert_eq!(

            file(&mut reader).unwrap(),

            File {

                space0: Whitespace {

                    value: String::from(" "),

                    source_info: SourceInfo::new(Pos::new(1, 6), Pos::new(1, 7)),

                },

                filename: Template {

                    delimiter: None,

                    elements: vec![TemplateElement::String {

                        value: String::from("filename1"),

                        encoded: String::from("filename1"),

                    }],

                    source_info: SourceInfo::new(Pos::new(1, 7), Pos::new(1, 16)),

                },

                space1: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 16), Pos::new(1, 16)),

                },

            }

        );

        let mut reader = Reader::new("file, tmp/filename1;");

        assert_eq!(

            file(&mut reader).unwrap(),

            File {

                space0: Whitespace {

                    value: String::from(" "),

                    source_info: SourceInfo::new(Pos::new(1, 6), Pos::new(1, 7)),

                },

                filename: Template {

                    delimiter: None,

                    elements: vec![TemplateElement::String {

                        value: String::from("tmp/filename1"),

                        encoded: String::from("tmp/filename1"),

                    }],

                    source_info: SourceInfo::new(Pos::new(1, 7), Pos::new(1, 20)),

                },

                space1: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 20), Pos::new(1, 20)),

                },

            }

        );

        let mut reader = Reader::new(r"file, tmp/filename\ with\ spaces.txt;");

        assert_eq!(

            file(&mut reader).unwrap(),

            File {

                space0: Whitespace {

                    value: String::from(" "),

                    source_info: SourceInfo::new(Pos::new(1, 6), Pos::new(1, 7)),

                },

                filename: Template {

                    elements: vec![TemplateElement::String {

                        value: String::from("tmp/filename with spaces.txt"),

                        encoded: String::from("tmp/filename\\ with\\ spaces.txt"),

                    }],

                    delimiter: None,

                    source_info: SourceInfo::new(Pos::new(1, 7), Pos::new(1, 37)),

                },

                space1: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 37), Pos::new(1, 37)),

                },

            }

        );

    }

    #[test]

    fn test_file_error() {

        let mut reader = Reader::new("fil; filename1;");

        let error = file(&mut reader).err().unwrap();

        assert_eq!(error.pos, Pos { line: 1, column: 1 });

        assert!(error.recoverable);

        let mut reader = Reader::new("file, filename1");

        let error = file(&mut reader).err().unwrap();

        assert_eq!(

            error.pos,

            Pos {

                line: 1,

                column: 16,

            }

        );

        assert!(!error.recoverable);

        assert_eq!(

            error.kind,

            ParseErrorKind::Expecting {

                value: String::from(";")

            }

        );

        let mut reader = Reader::new(r"file, tmp/filename\ with\ unescaped .txt;");

        let error = file(&mut reader).err().unwrap();

        assert_eq!(

            error.pos,

            Pos {

                line: 1,

                column: 37,

            }

        );

        assert!(!error.recoverable);

        assert_eq!(

            error.kind,

            ParseErrorKind::Expecting {

                value: String::from(";")

            }

        );

    }

    #[test]

    fn test_base64() {

        let mut reader = Reader::new("base64,  T WE=;xxx");

        assert_eq!(

            base64(&mut reader).unwrap(),

            Base64 {

                space0: Whitespace {

                    value: String::from("  "),

                    source_info: SourceInfo::new(Pos::new(1, 8), Pos::new(1, 10)),

                },

                value: vec![77, 97],

                encoded: String::from("T WE="),

                space1: Whitespace {

                    value: String::new(),

                    source_info: SourceInfo::new(Pos::new(1, 15), Pos::new(1, 15)),

                },

            }

        );

        assert_eq!(reader.cursor().index, 15);

    }

}