// Copyright 2018 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.

use crate::parser::{self, ArgKind};

#[derive(Debug)]
pub struct Protocol {
    pub name: String,
    pub copyright: Option<String>,
    pub description: Option<Description>,
    pub interfaces: Vec<Interface>,
}

#[derive(Debug)]
pub struct Description {
    pub summary: String,
    pub description: String,
}

#[derive(Debug)]
pub struct Interface {
    pub name: String,
    pub version: u32,
    pub description: Option<Description>,
    pub requests: Vec<Message>,
    pub events: Vec<Message>,
    pub enums: Vec<Enum>,
}

#[derive(Debug)]
pub struct Message {
    pub name: String,
    pub since: u32,
    pub request_type: Option<String>,
    pub description: Option<Description>,
    pub args: Vec<Arg>,
}

#[derive(Debug)]
pub struct Arg {
    pub name: String,
    pub kind: ArgKind,
    pub summary: Option<String>,
    pub interface: Option<String>,
    pub nullable: bool,
    pub enum_type: Option<String>,
    pub description: Option<Description>,
}

#[derive(Debug)]
pub struct Enum {
    pub name: String,
    pub since: u32,
    pub bitfield: bool,
    pub description: Option<Description>,
    pub entries: Vec<EnumEntry>,
}

#[derive(Debug)]
pub struct EnumEntry {
    pub name: String,
    pub value: i64,
    pub summary: Option<String>,
    pub since: u32,
    pub description: Option<Description>,
}

pub type AstError = String;
pub type AstResult<T> = Result<T, AstError>;

fn build_protocol(node: parser::ParseNode) -> AstResult<Protocol> {
    if let parser::ParseElement::Protocol { name } = node.element {
        let mut copyright: Option<String> = None;
        let mut description: Option<Description> = None;
        let mut interfaces: Vec<Interface> = Vec::new();
        for child in node.children {
            match &child.element {
                parser::ParseElement::Copyright => copyright = Some(build_copyright(child)?),
                parser::ParseElement::Description { .. } => {
                    description = Some(build_description(child)?)
                }
                parser::ParseElement::Interface { .. } => interfaces.push(build_interface(child)?),
                _ => return Err("Unsupported".to_owned()),
            }
        }
        Ok(Protocol {
            name: name,
            copyright,
            description,
            interfaces,
        })
    } else {
        Err("Unexpected Element; expected Protocol".to_owned())
    }
}

fn build_copyright(node: parser::ParseNode) -> AstResult<String> {
    if let Some(copyright) = node.body {
        Ok(copyright)
    } else {
        Err(format!("Unexpected node {:?}", node))
    }
}

fn build_description(node: parser::ParseNode) -> AstResult<Description> {
    if let parser::ParseElement::Description { summary } = node.element {
        Ok(Description {
            summary,
            description: node.body.unwrap_or("".to_owned()),
        })
    } else {
        Err("Invalid node".to_owned())
    }
}

fn build_interface(node: parser::ParseNode) -> AstResult<Interface> {
    if let parser::ParseElement::Interface { name, version } = node.element {
        let mut description: Option<Description> = None;
        let mut requests: Vec<Message> = Vec::new();
        let mut events: Vec<Message> = Vec::new();
        let mut enums: Vec<Enum> = Vec::new();
        for child in node.children {
            match &child.element {
                parser::ParseElement::Description { .. } => {
                    description = Some(build_description(child)?)
                }
                parser::ParseElement::Request { .. } => requests.push(build_request(child)?),
                parser::ParseElement::Event { .. } => events.push(build_event(child)?),
                parser::ParseElement::Enum { .. } => enums.push(build_enum(child)?),
                _ => return Err("Unsupported".to_owned()),
            }
        }
        Ok(Interface {
            name,
            version,
            description,
            requests,
            events,
            enums,
        })
    } else {
        Err("Invalid node".to_owned())
    }
}

fn build_request(node: parser::ParseNode) -> AstResult<Message> {
    if let parser::ParseElement::Request {
        name,
        since,
        request_type,
    } = node.element
    {
        let mut description: Option<Description> = None;
        let mut args: Vec<Arg> = Vec::new();
        for child in node.children {
            match &child.element {
                parser::ParseElement::Description { .. } => {
                    description = Some(build_description(child)?)
                }
                parser::ParseElement::Arg { .. } => args.append(&mut build_arg(child)?),
                _ => return Err("Unsupported".to_owned()),
            }
        }
        Ok(Message {
            name,
            since,
            request_type,
            description,
            args,
        })
    } else {
        Err("Invalid node".to_owned())
    }
}

fn build_event(node: parser::ParseNode) -> AstResult<Message> {
    if let parser::ParseElement::Event { name, since } = node.element {
        let mut description: Option<Description> = None;
        let mut args: Vec<Arg> = Vec::new();
        for child in node.children {
            match &child.element {
                parser::ParseElement::Description { .. } => {
                    description = Some(build_description(child)?)
                }
                parser::ParseElement::Arg { .. } => args.append(&mut build_arg(child)?),
                _ => return Err("Unsupported".to_owned()),
            }
        }
        Ok(Message {
            name,
            since,
            description,
            args,
            request_type: None,
        })
    } else {
        Err("Invalid node".to_owned())
    }
}

fn build_arg(node: parser::ParseNode) -> AstResult<Vec<Arg>> {
    if let parser::ParseElement::Arg {
        name,
        kind,
        summary,
        interface,
        nullable,
        enum_type,
    } = node.element
    {
        let mut description: Option<Description> = None;
        for child in node.children {
            match &child.element {
                parser::ParseElement::Description { .. } => {
                    description = Some(build_description(child)?)
                }
                _ => return Err("Unsupported".to_owned()),
            }
        }
        let arg = Arg {
            name,
            kind,
            summary,
            interface,
            nullable,
            enum_type,
            description,
        };
        // wayland has a slightly different serialization of untyped new_id
        // arguments. Instead of just sending the object id, the interface name
        // and version are sent first. This primarily impacts the
        // wl_registry::bind request.
        if arg.kind == ArgKind::NewId && arg.interface.is_none() {
            Ok(vec![
                Arg {
                    name: format!("{}_interface_name", arg.name),
                    kind: ArgKind::String,
                    summary: None,
                    interface: None,
                    nullable: false,
                    enum_type: None,
                    description: None,
                },
                Arg {
                    name: format!("{}_interface_version", arg.name),
                    kind: ArgKind::Uint,
                    summary: None,
                    interface: None,
                    nullable: false,
                    enum_type: None,
                    description: None,
                },
                arg,
            ])
        } else {
            Ok(vec![arg])
        }
    } else {
        Err("Invalid node".to_owned())
    }
}

fn build_enum(node: parser::ParseNode) -> AstResult<Enum> {
    if let parser::ParseElement::Enum {
        name,
        since,
        bitfield,
    } = node.element
    {
        let mut description: Option<Description> = None;
        let mut entries: Vec<EnumEntry> = Vec::new();
        for child in node.children {
            match &child.element {
                parser::ParseElement::Description { .. } => {
                    description = Some(build_description(child)?)
                }
                parser::ParseElement::EnumEntry { .. } => entries.push(build_enum_entry(child)?),
                _ => return Err("Unsupported".to_owned()),
            }
        }
        Ok(Enum {
            name,
            since,
            bitfield,
            description,
            entries,
        })
    } else {
        Err("Invalid node".to_owned())
    }
}

fn build_enum_entry(node: parser::ParseNode) -> AstResult<EnumEntry> {
    if let parser::ParseElement::EnumEntry {
        name,
        value,
        summary,
        since,
    } = node.element
    {
        let mut description: Option<Description> = None;
        for child in node.children {
            match &child.element {
                parser::ParseElement::Description { .. } => {
                    description = Some(build_description(child)?)
                }
                _ => return Err("Unsupported".to_owned()),
            }
        }
        Ok(EnumEntry {
            name,
            value,
            summary,
            since,
            description,
        })
    } else {
        Err("Invalid node".to_owned())
    }
}

impl Protocol {
    pub fn from_parse_tree(parse_tree: parser::ParseNode) -> AstResult<Protocol> {
        build_protocol(parse_tree)
    }
}