/*

 * Hurl (https://hurl.dev)

 * Copyright (C) 2025 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::{CertificateAttributeName, Query, QueryValue, RegexValue, SourceInfo};

use crate::combinator::{choice, ParseError as ParseErrorTrait};

use crate::parser::cookiepath::cookiepath;

use crate::parser::primitives::{literal, one_or_more_spaces, regex, try_literal};

use crate::parser::string::{quoted_oneline_string, quoted_template};

use crate::parser::{ParseError, ParseErrorKind, ParseResult};

use crate::reader::{Pos, Reader};

}

}

}

}

}

    // Read the whole value of the coookie path and parse it with a specialized reader.

    // todo should work with an encodedString in order to support escape sequence

    // or decode escape sequence with the cookiepath parser

    // We will parse the cookiepath value without `"`.

}

}

}

    //let expr = jsonpath_expr(reader)?;

    //  let start = reader.state.pos.clone();

    //    let end = reader.state.pos.clone();

    //    let expr = Template {

    //        elements: template.elements.iter().map(|e| match e {

    //            TemplateElement::String { value, encoded } => HurlTemplateElement::Literal {

    //                value: HurlString2 { value: value.clone(), encoded: Some(encoded.clone()) }

    //            },

    //            TemplateElement::Expression(value) => HurlTemplateElement::Expression { value: value.clone() }

    //        }).collect(),

    //        quotes: true,

    //        source_info: SourceInfo { start, end },

    //    };

}

}

}

}

}

}

}

}

}

    } else {

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::ast::{

        CookieAttribute, CookieAttributeName, CookiePath, Filter, FilterValue, Template,

        TemplateElement, Whitespace,

    };

    use crate::parser::filter::filters;

    use crate::reader::Pos;

    #[test]

    fn test_query() {

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

        assert_eq!(

            query(&mut reader).unwrap(),

            Query {

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

                value: QueryValue::Status,

            }

        );

    }

    #[test]

    fn test_status_query() {

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

        assert_eq!(

            query(&mut reader).unwrap(),

            Query {

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

                value: QueryValue::Status,

            }

        );

    }

    #[test]

    fn test_header_query() {

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

        assert_eq!(

            header_query(&mut reader).unwrap(),

            QueryValue::Header {

                space0: Whitespace {

                    value: String::from(" "),

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

                },

                name: Template {

                    delimiter: Some('"'),

                    elements: vec![TemplateElement::String {

                        value: "Foo".to_string(),

                        encoded: "Foo".to_string(),

                    }],

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

                },

            }

        );

    }

    #[test]

    fn test_cookie_query() {

        let mut reader = Reader::new("cookie \"Foo[Domain]\"");

        assert_eq!(

            cookie_query(&mut reader).unwrap(),

            QueryValue::Cookie {

                space0: Whitespace {

                    value: String::from(" "),

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

                },

                expr: CookiePath {

                    name: Template {

                        delimiter: None,

                        elements: vec![TemplateElement::String {

                            value: "Foo".to_string(),

                            encoded: "Foo".to_string(),

                        }],

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

                    },

                    attribute: Some(CookieAttribute {

                        space0: Whitespace {

                            value: String::new(),

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

                        },

                        name: CookieAttributeName::Domain("Domain".to_string()),

                        space1: Whitespace {

                            value: String::new(),

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

                        },

                    }),

                },

            }

        );

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

        // todo test with escape sequence

        //let mut reader = Reader::init("cookie \"cookie\u{31}\"");

    }

    #[test]

    fn test_xpath_query() {

        let mut reader = Reader::new("xpath \"normalize-space(//head/title)\"");

        assert_eq!(

            xpath_query(&mut reader).unwrap(),

            QueryValue::Xpath {

                space0: Whitespace {

                    value: String::from(" "),

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

                },

                expr: Template {

                    delimiter: Some('"'),

                    elements: vec![TemplateElement::String {

                        value: String::from("normalize-space(//head/title)"),

                        encoded: String::from("normalize-space(//head/title)"),

                    }],

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

                },

            },

        );

        let mut reader = Reader::new("xpath \"normalize-space(//div[contains(concat(' ',normalize-space(@class),' '),' monthly-price ')])\"");

        assert_eq!(xpath_query(&mut reader).unwrap(), QueryValue::Xpath {

            space0: Whitespace { value: String::from(" "), source_info: SourceInfo::new(Pos::new(1, 6), Pos::new(1, 7)) },

            expr: Template {

                delimiter: Some('"'),

                elements: vec![

                    TemplateElement::String {

                        value: String::from("normalize-space(//div[contains(concat(' ',normalize-space(@class),' '),' monthly-price ')])"),

                        encoded: String::from("normalize-space(//div[contains(concat(' ',normalize-space(@class),' '),' monthly-price ')])"),

                    }

                ],

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

            },

        });

    }

    #[test]

    fn test_jsonpath_query() {

        let mut reader = Reader::new("jsonpath \"$['statusCode']\"");

        assert_eq!(

            jsonpath_query(&mut reader).unwrap(),

            QueryValue::Jsonpath {

                space0: Whitespace {

                    value: String::from(" "),

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

                },

                expr: Template {

                    elements: vec![TemplateElement::String {

                        value: "$['statusCode']".to_string(),

                        encoded: "$['statusCode']".to_string(),

                    }],

                    delimiter: Some('"'),

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

                },

            },

        );

        let mut reader = Reader::new("jsonpath \"$.success\"");

        assert_eq!(

            jsonpath_query(&mut reader).unwrap(),

            QueryValue::Jsonpath {

                space0: Whitespace {

                    value: String::from(" "),

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

                },

                expr: Template {

                    elements: vec![TemplateElement::String {

                        value: "$.success".to_string(),

                        encoded: "$.success".to_string(),

                    }],

                    delimiter: Some('"'),

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

                },

            },

        );

    }

    #[test]

    fn test_query_with_filters() {

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

        assert_eq!(

            query(&mut reader).unwrap(),

            Query {

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

                value: QueryValue::Body,

            }

        );

        assert_eq!(

            filters(&mut reader).unwrap(),

            vec![(

                Whitespace {

                    value: " ".to_string(),

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

                },

                Filter {

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

                    value: FilterValue::UrlDecode,

                }

            )]

        );

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

    }

}