// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

pub use crate::errors::ParseError;
pub use crate::parse::{check_resource, is_name};
use percent_encoding::percent_decode;
use std::fmt;
use url::Url;

/// Decoded representation of a fuchsia-boot URL.
///
/// fuchsia-boot:///path/to#path/to/resource
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BootUrl {
    path: String,
    resource: Option<String>,
}

impl BootUrl {
    pub fn parse(input: &str) -> Result<Self, ParseError> {
        let url = Url::parse(input)?;

        let scheme = url.scheme();
        if scheme != "fuchsia-boot" {
            return Err(ParseError::InvalidScheme);
        }

        let host = url.host().map(|h| h.to_string()).ok_or(ParseError::InvalidHost)?;
        if !host.is_empty() {
            return Err(ParseError::HostMustBeEmpty);
        }

        let path = url.path().to_string();

        // Validate that all path segments are valid.
        // Since host must be empty, first character of path must be '/'. Trim it.
        let check_path = &path[1..];
        if !check_path.is_empty() {
            let mut iter = check_path.split('/');
            while let Some(s) = iter.next() {
                if !is_name(s) {
                    return Err(ParseError::InvalidPath);
                }
            }
        }

        if url.query().is_some() {
            return Err(ParseError::CannotContainQueryParameters);
        }

        let resource = match url.fragment() {
            Some(resource) => {
                let resource = percent_decode(resource.as_bytes())
                    .decode_utf8()
                    .map_err(|_| ParseError::InvalidResourcePath)?;

                if resource.is_empty() {
                    None
                } else if check_resource(&resource) {
                    Some(resource.to_string())
                } else {
                    return Err(ParseError::InvalidResourcePath);
                }
            }
            None => None,
        };

        Ok(BootUrl { path, resource })
    }

    pub fn path(&self) -> &str {
        &self.path
    }

    pub fn resource(&self) -> Option<&str> {
        self.resource.as_ref().map(|s| s.as_str())
    }

    pub fn root_url(&self) -> BootUrl {
        BootUrl { path: self.path.clone(), resource: None }
    }

    pub fn new_path(path: String) -> Result<BootUrl, ParseError> {
        Ok(BootUrl { path: path.clone(), resource: None })
    }

    pub fn new_resource(path: String, resource: String) -> Result<BootUrl, ParseError> {
        let mut url = BootUrl::new_path(path)?;
        if resource.is_empty() || !check_resource(&resource) {
            return Err(ParseError::InvalidResourcePath);
        }
        url.resource = Some(resource);
        Ok(url)
    }
}

impl fmt::Display for BootUrl {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "fuchsia-boot://{}", self.path)?;
        if let Some(ref resource) = self.resource {
            write!(f, "#{}", percent_encoding::utf8_percent_encode(resource, crate::FRAGMENT))?;
        }

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    macro_rules! test_parse_ok {
        (
            $(
                $test_name:ident => {
                    url = $pkg_url:expr,
                    path = $pkg_path:expr,
                    resource = $pkg_resource:expr,
                }
            )+
        ) => {
            $(
                #[test]
                fn $test_name() {
                    let pkg_url = $pkg_url.to_string();
                    assert_eq!(
                        BootUrl::parse(&pkg_url),
                        Ok(BootUrl {
                            path: $pkg_path,
                            resource: $pkg_resource,
                        })
                    );
                }
            )+
        }
    }

    macro_rules! test_parse_err {
        (
            $(
                $test_name:ident => {
                    urls = $urls:expr,
                    err = $err:expr,
                }
            )+
        ) => {
            $(
                #[test]
                fn $test_name() {
                    for url in &$urls {
                        assert_eq!(
                            BootUrl::parse(url),
                            Err($err),
                        );
                    }
                }
            )+
        }
    }

    macro_rules! test_format {
        (
            $(
                $test_name:ident => {
                    parsed = $parsed:expr,
                    formatted = $formatted:expr,
                }
            )+
        ) => {
            $(
                #[test]
                fn $test_name() {
                    assert_eq!(
                        format!("{}", $parsed),
                        $formatted
                    );
                }
            )+
        }
    }

    test_parse_ok! {
        test_parse_absolute_path => {
            url = "fuchsia-boot:///package",
            path = "/package".to_string(),
            resource = None,
        }
        test_parse_multiple_path_segments => {
            url = "fuchsia-boot:///package/foo",
            path = "/package/foo".to_string(),
            resource = None,
        }
        test_parse_more_path_segments => {
            url = "fuchsia-boot:///package/foo/bar/baz",
            path = "/package/foo/bar/baz".to_string(),
            resource = None,
        }
        test_parse_root => {
            url = "fuchsia-boot:///",
            path = "/".to_string(),
            resource = None,
        }
        test_parse_empty_root => {
            url = "fuchsia-boot://",
            path = "/".to_string(),
            resource = None,
        }
        test_parse_resource => {
            url = "fuchsia-boot:///package#resource",
            path = "/package".to_string(),
            resource = Some("resource".to_string()),
        }
        test_parse_resource_with_path_segments => {
            url = "fuchsia-boot:///package/foo#resource",
            path = "/package/foo".to_string(),
            resource = Some("resource".to_string()),
        }
        test_parse_empty_resource => {
            url = "fuchsia-boot:///package#",
            path = "/package".to_string(),
            resource = None,
        }
        test_parse_root_empty_resource => {
            url = "fuchsia-boot:///#",
            path = "/".to_string(),
            resource = None,
        }
        test_parse_empty_root_empty_resource => {
            url = "fuchsia-boot://#",
            path = "/".to_string(),
            resource = None,
        }
    }

    test_parse_err! {
        test_parse_invalid_scheme => {
            urls = [
                "fuchsia-pkg://",
            ],
            err = ParseError::InvalidScheme,
        }
        test_parse_invalid_path => {
            urls = [
                "fuchsia-boot:////",
                "fuchsia-boot:///package:1234",
            ],
            err = ParseError::InvalidPath,
        }
        test_parse_invalid_path_segment => {
            urls = [
                "fuchsia-boot:///path/foo$bar/baz",
            ],
            err = ParseError::InvalidPath,
        }
        test_parse_path_cannot_be_longer_than_100_chars => {
            urls = [
                "fuchsia-boot:///12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901/",
            ],
            err = ParseError::InvalidPath,
        }
        test_parse_path_cannot_have_invalid_characters => {
            urls = [
                "fuchsia-boot:///$",
                "fuchsia-boot:///foo$bar",
            ],
            err = ParseError::InvalidPath,
        }
        test_parse_host_must_be_empty => {
            urls = [
                "fuchsia-boot://hello",
                "fuchsia-boot://user@fuchsia.com",
                "fuchsia-boot://user:password@fuchsia.com",
                "fuchsia-boot://:password@fuchsia.com",
            ],
            err = ParseError::HostMustBeEmpty,
        }
        test_parse_resource_cannot_be_slash => {
            urls = [
                "fuchsia-boot:///package#/",
            ],
            err = ParseError::InvalidResourcePath,
        }
        test_parse_resource_cannot_start_with_slash => {
            urls = [
                "fuchsia-boot:///package#/foo",
                "fuchsia-boot:///package#/foo/bar",
            ],
            err = ParseError::InvalidResourcePath,
        }
        test_parse_resource_cannot_end_with_slash => {
            urls = [
                "fuchsia-boot:///package#foo/",
                "fuchsia-boot:///package#foo/bar/",
            ],
            err = ParseError::InvalidResourcePath,
        }
        test_parse_resource_cannot_contain_dot_dot => {
            urls = [
                "fuchsia-boot:///package#foo/../bar",
            ],
            err = ParseError::InvalidResourcePath,
        }
        test_parse_resource_cannot_contain_empty_segments => {
            urls = [
                "fuchsia-boot:///package#foo//bar",
            ],
            err = ParseError::InvalidResourcePath,
        }
        test_parse_resource_cannot_contain_percent_encoded_nul_chars => {
            urls = [
                "fuchsia-boot:///package#foo%00bar",
            ],
            err = ParseError::InvalidResourcePath,
        }
        test_parse_rejects_query_params => {
            urls = [
                "fuchsia-boot:///package?foo=bar",
            ],
            err = ParseError::CannotContainQueryParameters,
        }
    }

    test_format! {
        test_format_path_url => {
            parsed = BootUrl::new_path("/path/to".to_string()).unwrap(),
            formatted = "fuchsia-boot:///path/to",
        }
        test_format_resource_url => {
            parsed = BootUrl::new_resource("/path/to".to_string(), "path/to/resource".to_string()).unwrap(),
            formatted = "fuchsia-boot:///path/to#path/to/resource",
        }
    }

    #[test]
    fn test_new_path() {
        let url = BootUrl::new_path("/path/to".to_string()).unwrap();
        assert_eq!("/path/to", url.path());
        assert_eq!(None, url.resource());
        assert_eq!(url, url.root_url());
        assert_eq!("fuchsia-boot:///path/to", format!("{}", url.root_url()));
    }

    #[test]
    fn test_new_resource() {
        let url = BootUrl::new_resource("/path/to".to_string(), "foo/bar".to_string()).unwrap();
        assert_eq!("/path/to", url.path());
        assert_eq!(Some("foo/bar"), url.resource());
        let mut url_no_resource = url.clone();
        url_no_resource.resource = None;
        assert_eq!(url_no_resource, url.root_url());
        assert_eq!("fuchsia-boot:///path/to", format!("{}", url.root_url()));
    }
}