// 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 std::borrow::Cow;
use std::io;

use crate::ast;
use crate::parser::ArgKind;

pub type Result = io::Result<()>;

pub struct Codegen<W: io::Write> {
    w: W,
}

impl<W: io::Write> Codegen<W> {
    pub fn new(w: W) -> Codegen<W> {
        Codegen { w }
    }

    pub fn codegen(&mut self, protocol: ast::Protocol, dependencies: &[String]) -> Result {
        self.codegen_protocol(protocol, dependencies)
    }

    fn codegen_protocol(&mut self, protocol: ast::Protocol, dependencies: &[String]) -> Result {
        writeln!(self.w, "// GENERATED FILE -- DO NOT EDIT")?;
        if let Some(ref c) = protocol.copyright {
            writeln!(self.w, "//")?;
            for line in c.trim().lines() {
                writeln!(self.w, "// {}", line.trim())?;
            }
        }
        writeln!(
            self.w,
            "
#![allow(warnings)]
use bitflags::*;
use failure;
use fuchsia_wayland_core::{{ArgKind, Arg, Enum, Fixed, FromArgs, IntoMessage, Message,
                            MessageGroupSpec, MessageHeader, MessageSpec, MessageType,
                            NewId, NewObject, ObjectId, EncodeError, DecodeError,
                            Interface }};"
        )?;
        for dep in dependencies.iter() {
            writeln!(self.w, "use {}::*;", dep)?;
        }

        for interface in protocol.interfaces.into_iter() {
            // Most symbols will be defined in a nested module, but re-export
            // some into the top-level namespace.
            //
            // Ex, for wl_display:
            //
            // pub mod wl_display {
            //      pub enum Request { ... }
            //      pub enum Event { ... }
            //      pub struct WlDisplay;
            // }
            //
            // pub use wl_display::WlDisplay;
            // pub use wl_display::Request as WlDisplayRequest;
            // pub use wl_display::Event as WlDisplayEvent;
            writeln!(self.w, "pub mod {} {{", interface.name)?;
            writeln!(self.w, "use super::*;")?;
            self.codegen_interface_trait(&interface)?;
            self.codegen_message_enum(
                "Request",
                &interface,
                &interface.requests,
                format_dispatch_arg_rust,
            )?;
            self.codegen_message_enum(
                "Event",
                &interface,
                &interface.events,
                format_wire_arg_rust,
            )?;
            self.codegen_impl_event(&interface.events)?;
            self.codegen_from_args(&interface.requests)?;
            self.codegen_enum_types(&interface)?;
            writeln!(self.w, "}} // mod {}", interface.name)?;
            writeln!(self.w, "")?;
            writeln!(
                self.w,
                "pub use crate::{}::{};",
                interface.name,
                interface.rust_name()
            )?;
            writeln!(
                self.w,
                "pub use crate::{}::Request as {}Request;",
                interface.name,
                interface.rust_name()
            )?;
            writeln!(
                self.w,
                "pub use crate::{}::Event as {}Event;",
                interface.name,
                interface.rust_name()
            )?;
        }
        Ok(())
    }

    /// Emits an enum that describes the set of messages for a single interface.
    /// Each interface will have a message enum for both Requests and Events.
    ///
    /// Ex:
    ///  pub enum MyInterfaceRequest {
    ///    Request1 { arg1: u32 },
    ///    Request2 { name: String},
    ///  }
    fn codegen_message_enum<F: Fn(&ast::Arg) -> Cow<str>>(
        &mut self, name: &str, interface: &ast::Interface, messages: &Vec<ast::Message>,
        arg_formatter: F,
    ) -> Result {
        writeln!(self.w, "#[derive(Debug)]")?;
        writeln!(self.w, "pub enum {enum_name} {{", enum_name = name)?;
        for message in messages.iter() {
            if let Some(ref d) = message.description {
                self.codegen_description(d, "    ")?;
            }
            if message.args.is_empty() {
                // For messages without args, emit a marker enum variant.
                //  Ex:
                //      Request::Message,
                writeln!(self.w, "    {},", message.rust_name())?;
            } else {
                // For messages with args, emit a struct enum variant with an
                // entry for each arg:
                //  Ex:
                //      Request::Message {
                //          arg1: u32,
                //          arg2: String,
                //      },
                writeln!(self.w, "    {} {{", message.rust_name())?;
                for arg in message.args.iter() {
                    if let Some(ref summary) = arg.summary {
                        for line in summary.lines() {
                            writeln!(self.w, "        /// {}", line.trim())?;
                        }
                    }
                    writeln!(
                        self.w,
                        "        {arg_name}: {arg_type},",
                        arg_name = arg.rust_name(),
                        arg_type = arg_formatter(&arg)
                    )?;
                }
                writeln!(self.w, "    }},")?;
            }
        }
        writeln!(self.w, "}}")?;
        writeln!(self.w, "")?;

        writeln!(self.w, "impl MessageType for {} {{", name)?;

        // Generate the log method:
        //
        // fn log(&self, this: ObjectId) -> String {
        //     let mut string = String::new();
        //     match *self {
        //         WlInterface::Message { ref arg } =>
        //             format!("wl_interface@{}::message(arg: {:?})", this, arg),
        //         ...
        //     }
        // }
        writeln!(self.w, "    fn log(&self, this: ObjectId) -> String {{")?;
        writeln!(self.w, "        match *self {{")?;
        for message in messages.iter() {
            writeln!(self.w, "            {}::{} {{", name, message.rust_name())?;
            for arg in message.args.iter() {
                writeln!(self.w, "                ref {},", arg.rust_name())?;
            }
            writeln!(self.w, "            }} => {{")?;

            // We're using format strings to build a format string, so this is
            // a little confusing. |message_args| are the set of strings that
            // will be joined to form the format string literal. |format_args|
            // are the rust expressions that will be used by the format string.
            //
            // Anytime we put a '{{}}' into |message_args|, we'll need a
            // corresponding expression pushed to |format_args|.
            //
            // We'll end up with something like:
            //      format!("some_interface@3::message1(arg1: {}, arg2: {})", arg1, arg2)
            write!(
                self.w,
                "                format!(\"{}@{{:?}}::{}(",
                interface.name, message.name
            )?;
            let mut message_args = vec![];
            let mut format_args: Vec<Cow<str>> = vec!["this".into()];
            for arg in message.args.iter() {
                match arg.kind {
                    ArgKind::Array => {
                        message_args.push(format!("{}: Array[{{}}]", arg.name));
                        format_args.push(format!("{}.len()", arg.rust_name()).into());
                    }
                    ArgKind::Fd => {
                        message_args.push(format!("{}: <handle>", arg.name));
                    }
                    _ => {
                        message_args.push(format!("{}: {{:?}}", arg.name));
                        format_args.push(arg.rust_name().into());
                    }
                }
            }
            writeln!(
                self.w,
                "{})\", {})",
                message_args.join(", "),
                format_args.join(", ")
            )?;
            writeln!(self.w, "            }}")?;
        }
        writeln!(self.w, "        }}")?;
        writeln!(self.w, "    }}")?;
        writeln!(self.w, "}}")?;
        Ok(())
    }

    /// Generates an impl for the Event trait for a set of messages. This
    /// will be the code that allows the message type to be serialized into
    /// a Message that can be sent over channel.
    ///
    /// Ex:
    ///   impl IntoMessage for Event {
    ///       fn into_message(self, id: u32) -> Result<Message, Self::Error> {
    ///           let mut header = MessageHeader {...};
    ///           let mut message = Message::new();
    ///           message.write_header(&header);
    ///           match self {
    ///           MyInterfaceEvent::Event1 { uint_arg } => {
    ///               message.write_arg(Arg::Uint(uint_arg))?;
    ///               header.opcode = 0;
    ///           },
    ///           // ... Encode other events...
    ///           }
    ///
    ///           // Rewrite header with proper ordinal & length.
    ///           header.length = msg.bytes().len() as u16;
    ///           message.rewind();
    ///           message.write_header(&header);
    ///       }
    ///   }
    fn codegen_impl_event(&mut self, messages: &Vec<ast::Message>) -> Result {
        write!(
            self.w,
            "\
impl IntoMessage for Event {{
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, Self::Error> {{
        let mut header = MessageHeader {{
            sender: id,
            opcode: 0,
            length: 0,
        }};
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {{"
        )?;

        for (op, event) in messages.iter().enumerate() {
            write!(
                self.w,
                "
        Event::{message_name} {{\n",
                message_name = to_camel_case(&event.name)
            )?;
            for arg in event.args.iter() {
                write!(
                    self.w,
                    "            {arg_name},\n",
                    arg_name = arg.rust_name()
                )?;
            }
            write!(self.w, "        }} => {{\n")?;
            for arg in event.args.iter() {
                write!(
                    self.w,
                    "            msg.write_arg({arg})?;\n",
                    arg = format_wire_arg(&arg, &arg.name)
                )?;
            }
            write!(
                self.w,
                "            header.opcode = {opcode};
        }},",
                opcode = op
            )?;
        }
        write!(
            self.w,
            "
        }}
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }}
}}\n"
        )
    }

    fn codegen_from_args(&mut self, messages: &Vec<ast::Message>) -> Result {
        write!(
            self.w,
            "\
impl FromArgs for Request {{
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, failure::Error> {{
        match op {{",
        )?;

        for (op, message) in messages.iter().enumerate() {
            write!(
                self.w,
                "
        {opcode} /* {op_name} */ => {{
            let mut iter = args.into_iter();
            Ok(Request::{message_name} {{\n",
                opcode = op,
                op_name = message.name,
                message_name = to_camel_case(&message.name)
            )?;
            for arg in message.args.iter() {
                writeln!(
                    self.w,
                    "                {}: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .{},",
                    arg.rust_name(),
                    arg_to_primitive(&arg)
                )?;
            }
            write!(
                self.w,
                "
            }})
        }},"
            )?;
        }
        write!(
            self.w,
            "
        _ => {{
            Err(DecodeError::InvalidOpcode(op).into())
        }},
        }}
    }}
}}\n"
        )
    }

    /// Generates a trait for each interface.
    ///
    /// Ex:
    ///   pub struct MyInterface;
    ///
    ///   impl Interface for MyInterface {
    ///       const NAME: &'static str = "my_interface";
    ///       const VERSION: u32 = 0;
    ///       type Request = MyInterfaceRequest;
    ///       type Event = MyInterfaceEvent;
    ///   }
    fn codegen_interface_trait(&mut self, interface: &ast::Interface) -> Result {
        let camel_name = to_camel_case(&interface.name);
        if let Some(ref d) = interface.description {
            self.codegen_description(d, "")?;
        }
        writeln!(self.w, "#[derive(Debug)]")?;
        writeln!(self.w, "pub struct {};", camel_name)?;
        writeln!(self.w, "")?;
        writeln!(self.w, "impl Interface for {} {{", camel_name)?;
        writeln!(
            self.w,
            "    const NAME: &'static str = \"{}\";",
            interface.name
        )?;
        writeln!(self.w, "    const VERSION: u32 = {};", interface.version)?;
        write!(self.w, "    const REQUESTS: MessageGroupSpec = ")?;
        self.codegen_message_group_spec(&interface.requests)?;
        write!(self.w, "    const EVENTS: MessageGroupSpec = ")?;
        self.codegen_message_group_spec(&interface.events)?;
        writeln!(self.w, "    type Request = Request;")?;
        writeln!(self.w, "    type Event = Event;")?;
        writeln!(self.w, "}}")?;
        writeln!(self.w, "")?;
        Ok(())
    }

    fn codegen_message_group_spec(&mut self, messages: &Vec<ast::Message>) -> Result {
        writeln!(self.w, "MessageGroupSpec(&[")?;
        for m in messages.iter() {
            writeln!(self.w, "        // {}", m.name)?;
            writeln!(self.w, "        MessageSpec(&[")?;
            for arg in m.args.iter() {
                writeln!(self.w, "            {},", format_arg_kind(&arg))?;
            }
            writeln!(self.w, "        ]),")?;
        }
        writeln!(self.w, "    ]);")?;
        Ok(())
    }

    fn codegen_enum_types(&mut self, interface: &ast::Interface) -> Result {
        for e in interface.enums.iter() {
            if e.bitfield {
                self.codegen_bitflags_enum(e)?;
            } else {
                self.codegen_value_enum(e)?;
            }
        }
        Ok(())
    }

    fn codegen_value_enum(&mut self, e: &ast::Enum) -> Result {
        if let Some(ref d) = e.description {
            self.codegen_description(d, "")?;
        }
        writeln!(self.w, "#[derive(Copy, Clone, Debug, Eq, PartialEq)]")?;
        writeln!(self.w, "#[repr(u32)]")?;
        writeln!(self.w, "pub enum {} {{", e.rust_name())?;
        for entry in e.entries.iter() {
            if let Some(ref s) = entry.summary {
                for l in s.lines() {
                    writeln!(self.w, "    /// {},", l.trim())?;
                }
            }
            writeln!(self.w, "    {},", entry.rust_name())?;
        }
        writeln!(self.w, "}}")?;
        writeln!(self.w, "")?;
        writeln!(self.w, "impl {} {{", e.rust_name())?;
        writeln!(self.w, "    pub fn from_bits(v: u32) -> Option<Self> {{")?;
        writeln!(self.w, "        match v {{")?;
        for entry in e.entries.iter() {
            writeln!(
                self.w,
                "        {} => Some({}::{}),",
                entry.value,
                e.rust_name(),
                entry.rust_name()
            )?;
        }
        writeln!(self.w, "        _ => None,")?;
        writeln!(self.w, "        }}")?;
        writeln!(self.w, "    }}")?;
        writeln!(self.w, "")?;
        writeln!(self.w, "    pub fn bits(&self) -> u32 {{")?;
        writeln!(self.w, "        *self as u32")?;
        writeln!(self.w, "    }}")?;
        writeln!(self.w, "}}")?;
        Ok(())
    }

    fn codegen_bitflags_enum(&mut self, e: &ast::Enum) -> Result {
        writeln!(self.w, "::bitflags::bitflags! {{")?;
        if let Some(ref d) = e.description {
            self.codegen_description(d, "    ")?;
        }
        writeln!(self.w, "    pub struct {}: u32 {{", e.rust_name())?;
        for entry in e.entries.iter() {
            if let Some(ref s) = entry.summary {
                for l in s.lines() {
                    writeln!(self.w, "        /// {},", l.trim())?;
                }
            }
            writeln!(
                self.w,
                "        const {} = {};",
                entry.rust_name(),
                entry.value
            )?;
        }
        writeln!(self.w, "    }}")?;
        writeln!(self.w, "}}")?;
        Ok(())
    }

    fn codegen_description(&mut self, d: &ast::Description, prefix: &str) -> Result {
        writeln!(self.w, "")?;
        for s in d.summary.as_str().trim().lines() {
            writeln!(self.w, "{}/// {}", prefix, s.trim())?;
        }
        writeln!(self.w, "{}///", prefix)?;
        for s in d.description.trim().lines() {
            writeln!(self.w, "{}/// {}", prefix, s.trim())?;
        }
        Ok(())
    }
}

fn to_camel_case(s: &str) -> String {
    s.split('_')
        .filter(|s| s.len() > 0)
        .map(|s| s[..1].to_uppercase() + &s[1..])
        .collect()
}

/// Enums can be referenced outside of the interface that defines them. When
/// arguments are tagged with an enum, they'll provide the path to the enum
/// in the form <interface>.<enum>.
///
/// For example, 'wl_output.transform' refers to the enum named 'transform'
/// that's defined in the 'wl_output' interface.
///
/// Since our rust modules already mirror this structure, we can simply use a
/// relative path to the enum when it's defined in the same interface, or
/// reference the interface module for foreign enums.
///
/// Ex:
///   Within the 'wl_output' module, the 'transform' enum can be referred to
///   as just 'Transform'.
///
///   When 'wl_output' is referred to from another module we can use the crate-
///   relative path 'crate::wl_output::Transform'.
///
/// Note we could always use the crate-relative path, but that would require
/// passing the 'interface' parameter around to lots of logic that otherwise
/// doesn't care.
fn enum_path(name: &str) -> String {
    let parts: Vec<&str> = name.splitn(2, ".").collect();
    if parts.len() == 1 {
        to_camel_case(name)
    } else {
        format!("crate::{}::{}", parts[0], to_camel_case(parts[1]))
    }
}

fn format_dispatch_arg_rust(arg: &ast::Arg) -> Cow<str> {
    if let Some(ref enum_type) = arg.enum_type {
        return format!("Enum<{}>", enum_path(enum_type)).into();
    }
    match arg.kind {
        ArgKind::Int => "i32".into(),
        ArgKind::Uint => "u32".into(),
        ArgKind::Fixed => "Fixed".into(),
        ArgKind::String => "String".into(),
        ArgKind::Object => "ObjectId".into(),
        ArgKind::NewId => {
            if let Some(interface) = &arg.interface {
                format!("NewObject<{}>", to_camel_case(&interface)).into()
            } else {
                "ObjectId".into()
            }
        }
        ArgKind::Array => "Vec<u8>".into(),
        ArgKind::Fd => "fuchsia_zircon::Handle".into(),
    }
}

fn format_wire_arg_rust(arg: &ast::Arg) -> Cow<str> {
    if let Some(ref enum_type) = arg.enum_type {
        return enum_path(enum_type).into();
    }
    match arg.kind {
        ArgKind::Int => "i32",
        ArgKind::Uint => "u32",
        ArgKind::Fixed => "Fixed",
        ArgKind::String => "String",
        ArgKind::Object => "ObjectId",
        ArgKind::NewId => "NewId",
        ArgKind::Array => "Vec<u8>",
        ArgKind::Fd => "fuchsia_zircon::Handle",
    }
    .into()
}

fn format_arg_kind(arg: &ast::Arg) -> &'static str {
    match arg.kind {
        ArgKind::Int => "ArgKind::Int",
        ArgKind::Uint => "ArgKind::Uint",
        ArgKind::Fixed => "ArgKind::Fixed",
        ArgKind::String => "ArgKind::String",
        ArgKind::Object => "ArgKind::Object",
        ArgKind::NewId => "ArgKind::NewId",
        ArgKind::Array => "ArgKind::Array",
        ArgKind::Fd => "ArgKind::Handle",
    }
}

fn format_wire_arg(arg: &ast::Arg, var: &str) -> String {
    if arg.enum_type.is_some() {
        return format!("Arg::Uint({}.bits())", var);
    }
    match arg.kind {
        ArgKind::Int => format!("Arg::Int({})", var),
        ArgKind::Uint => format!("Arg::Uint({})", var),
        ArgKind::Fixed => format!("Arg::Fixed({})", var),
        ArgKind::String => format!("Arg::String({})", var),
        ArgKind::Object => format!("Arg::Object({})", var),
        ArgKind::NewId => format!("Arg::NewId({})", var),
        ArgKind::Array => format!("Arg::Array({})", var),
        ArgKind::Fd => format!("Arg::Handle({})", var),
    }
}

fn arg_to_primitive(arg: &ast::Arg) -> String {
    if let Some(ref enum_type) = arg.enum_type {
        return format!(
            "as_uint().map(|i| match {}::from_bits(i) {{
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 }})?",
            enum_path(enum_type)
        );
    }
    match arg.kind {
        ArgKind::Int => "as_int()?",
        ArgKind::Uint => "as_uint()?",
        ArgKind::Fixed => "as_fixed()?.into()",
        ArgKind::String => "as_string()?",
        ArgKind::Object => "as_object()?",
        ArgKind::NewId => "as_new_id()?.into()",
        ArgKind::Array => "as_array()?",
        ArgKind::Fd => "as_handle()?",
    }
    .to_string()
}

/// Helper trait for transforming wayland protocol names into the rust
/// counterparts.
///
/// Ex, wl_display is written WlDisplay in rust code.
trait RustName {
    fn rust_name(&self) -> String;
}

impl RustName for ast::EnumEntry {
    // some wayland enums are just numbers, which would result in illegal rust
    // symbols. If we see a name that starts with a number we'll just prefix
    // with '_'.
    fn rust_name(&self) -> String {
        let is_digit = self.name.chars().next().map_or(false, |c| c.is_digit(10));
        let prefix = if is_digit { "_" } else { "" };
        format!("{}{}", prefix, to_camel_case(&self.name))
    }
}

fn is_rust_keyword(s: &str) -> bool {
    match s {
        "as" | "break" | "const" | "continue" | "crate" | "dyn" | "else" | "enum" | "extern"
        | "false" | "fn" | "for" | "if" | "impl" | "in" | "let" | "loop" | "match" | "mod"
        | "move" | "mut" | "pub" | "ref" | "return" | "Self" | "self" | "static" | "struct"
        | "super" | "trait" | "true" | "type" | "unsafe" | "use" | "where" | "while"
        | "abstract" | "async" | "await" | "become" | "box" | "do" | "final" | "macro"
        | "override" | "priv" | "try" | "typeof" | "unsized" | "virtual" | "yield" => true,
        _ => false,
    }
}

impl RustName for ast::Arg {
    fn rust_name(&self) -> String {
        if is_rust_keyword(&self.name) {
            format!("r#{}", self.name)
        } else {
            self.name.to_owned()
        }
    }
}

impl RustName for ast::Message {
    fn rust_name(&self) -> String {
        to_camel_case(&self.name)
    }
}

impl RustName for ast::Enum {
    fn rust_name(&self) -> String {
        to_camel_case(&self.name)
    }
}

impl RustName for ast::Interface {
    fn rust_name(&self) -> String {
        to_camel_case(&self.name)
    }
}