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

#pragma once

#include <memory>
#include <utility>
#include <vector>

#include "token.h"

namespace fidl {

enum struct Nullability {
    Nullable,
    Nonnullable,
};

struct Identifier {
    Identifier(Token identifier)
        : identifier(identifier) {}

    Token identifier;
};

struct CompoundIdentifier {
    CompoundIdentifier(std::vector<std::unique_ptr<Identifier>> components)
        : components(std::move(components)) {}

    std::vector<std::unique_ptr<Identifier>> components;
};

struct Literal {
    virtual ~Literal() {}
};

struct StringLiteral : public Literal {
    StringLiteral(Token literal)
        : literal(literal) {}

    Token literal;
};

struct NumericLiteral : public Literal {
    NumericLiteral(Token literal)
        : literal(literal) {}

    Token literal;
};

struct TrueLiteral : public Literal {
};

struct FalseLiteral : public Literal {
};

struct DefaultLiteral : public Literal {
};

struct Constant {
    virtual ~Constant() {}
};

struct IdentifierConstant : Constant {
    IdentifierConstant(std::unique_ptr<CompoundIdentifier> identifier)
        : identifier(std::move(identifier)) {}

    std::unique_ptr<CompoundIdentifier> identifier;
};

struct LiteralConstant : Constant {
    LiteralConstant(std::unique_ptr<Literal> literal)
        : literal(std::move(literal)) {}

    std::unique_ptr<Literal> literal;
};

struct Type {
    virtual ~Type() {}
};

struct ArrayType : public Type {
    ArrayType(std::unique_ptr<Type> element_type,
              std::unique_ptr<Constant> element_count)
        : element_type(std::move(element_type)),
          element_count(std::move(element_count)) {}

    std::unique_ptr<Type> element_type;
    std::unique_ptr<Constant> element_count;
};

struct VectorType : public Type {
    VectorType(std::unique_ptr<Type> element_type,
               std::unique_ptr<Constant> maybe_element_count,
               Nullability nullability)
        : element_type(std::move(element_type)),
          maybe_element_count(std::move(maybe_element_count)),
          nullability(nullability) {}

    std::unique_ptr<Type> element_type;
    std::unique_ptr<Constant> maybe_element_count;
    Nullability nullability;
};

struct StringType : public Type {
    StringType(std::unique_ptr<Constant> maybe_element_count,
               Nullability nullability)
        : maybe_element_count(std::move(maybe_element_count)),
          nullability(nullability) {}

    std::unique_ptr<Constant> maybe_element_count;
    Nullability nullability;
};

struct HandleType : public Type {
    enum struct Subtype {
        Handle,
        Process,
        Thread,
        Vmo,
        Channel,
        Event,
        Port,
        Interrupt,
        Iomap,
        Pci,
        Log,
        Socket,
        Resource,
        Eventpair,
        Job,
        Vmar,
        Fifo,
        Hypervisor,
        Guest,
        Timer,
    };

    HandleType(Subtype subtype, Nullability nullability)
        : subtype(subtype),
          nullability(nullability) {}

    Subtype subtype;
    Nullability nullability;
};

struct RequestType : public Type {
    RequestType(std::unique_ptr<CompoundIdentifier> subtype,
                Nullability nullability)
        : subtype(std::move(subtype)),
          nullability(nullability) {}

    std::unique_ptr<CompoundIdentifier> subtype;
    Nullability nullability;
};

struct IdentifierType : public Type {
    IdentifierType(std::unique_ptr<CompoundIdentifier> identifier,
                   Nullability nullability)
        : identifier(std::move(identifier)),
          nullability(nullability) {}

    std::unique_ptr<CompoundIdentifier> identifier;
    Nullability nullability;
};

struct PrimitiveType : public Type {
    enum struct TypeKind {
        Bool,
        Int8,
        Int16,
        Int32,
        Int64,
        Uint8,
        Uint16,
        Uint32,
        Uint64,
        Float32,
        Float64,
    };

    PrimitiveType(TypeKind type_kind)
        : type_kind(type_kind) {}

    TypeKind type_kind;
};

struct Using {
    Using(std::unique_ptr<CompoundIdentifier> using_path,
          std::unique_ptr<Identifier> maybe_alias)
        : using_path(std::move(using_path)),
          maybe_alias(std::move(maybe_alias)) {}

    std::unique_ptr<CompoundIdentifier> using_path;
    std::unique_ptr<Identifier> maybe_alias;
};

struct ConstDeclaration {
    ConstDeclaration(std::unique_ptr<Type> type,
                     std::unique_ptr<Identifier> identifier,
                     std::unique_ptr<Constant> constant)
        : type(std::move(type)),
          identifier(std::move(identifier)),
          constant(std::move(constant)) {}

    std::unique_ptr<Type> type;
    std::unique_ptr<Identifier> identifier;
    std::unique_ptr<Constant> constant;
};

struct EnumMemberValue {
    virtual ~EnumMemberValue() {}
};

struct EnumMemberValueIdentifier : public EnumMemberValue {
    EnumMemberValueIdentifier(std::unique_ptr<CompoundIdentifier> identifier)
        : identifier(std::move(identifier)) {}

    std::unique_ptr<CompoundIdentifier> identifier;
};

struct EnumMemberValueNumeric : public EnumMemberValue {
    EnumMemberValueNumeric(std::unique_ptr<NumericLiteral> literal)
        : literal(std::move(literal)) {}

    std::unique_ptr<NumericLiteral> literal;
};

struct EnumMember {
    EnumMember(std::unique_ptr<Identifier> identifier,
               std::unique_ptr<EnumMemberValue> maybe_value)
        : identifier(std::move(identifier)),
          maybe_value(std::move(maybe_value)) {}

    std::unique_ptr<Identifier> identifier;
    std::unique_ptr<EnumMemberValue> maybe_value;
};

struct EnumDeclaration {
    EnumDeclaration(std::unique_ptr<Identifier> identifier,
                    std::unique_ptr<PrimitiveType> maybe_subtype,
                    std::vector<std::unique_ptr<EnumMember>> members)
        : identifier(std::move(identifier)),
          maybe_subtype(std::move(maybe_subtype)),
          members(std::move(members)) {}

    std::unique_ptr<Identifier> identifier;
    std::unique_ptr<PrimitiveType> maybe_subtype;
    std::vector<std::unique_ptr<EnumMember>> members;
};

struct Parameter {
    Parameter(std::unique_ptr<Type> type,
              std::unique_ptr<Identifier> identifier)
        : type(std::move(type)),
          identifier(std::move(identifier)) {}

    std::unique_ptr<Type> type;
    std::unique_ptr<Identifier> identifier;
};

struct ParameterList {
    ParameterList(std::vector<std::unique_ptr<Parameter>> parameter_list)
        : parameter_list(std::move(parameter_list)) {}

    std::vector<std::unique_ptr<Parameter>> parameter_list;
};

struct InterfaceMemberMethod {
    InterfaceMemberMethod(std::unique_ptr<NumericLiteral> ordinal,
                          std::unique_ptr<Identifier> identifier,
                          std::unique_ptr<ParameterList> parameter_list,
                          std::unique_ptr<ParameterList> maybe_response)
        : ordinal(std::move(ordinal)),
          identifier(std::move(identifier)),
          parameter_list(std::move(parameter_list)),
          maybe_response(std::move(maybe_response)) {}

    std::unique_ptr<NumericLiteral> ordinal;
    std::unique_ptr<Identifier> identifier;
    std::unique_ptr<ParameterList> parameter_list;
    std::unique_ptr<ParameterList> maybe_response;
};

struct InterfaceDeclaration {
    InterfaceDeclaration(std::unique_ptr<Identifier> identifier,
                         std::vector<std::unique_ptr<ConstDeclaration>> const_members,
                         std::vector<std::unique_ptr<EnumDeclaration>> enum_members,
                         std::vector<std::unique_ptr<InterfaceMemberMethod>> method_members)
        : identifier(std::move(identifier)),
          const_members(std::move(const_members)),
          enum_members(std::move(enum_members)),
          method_members(std::move(method_members)) {}

    std::unique_ptr<Identifier> identifier;
    std::vector<std::unique_ptr<ConstDeclaration>> const_members;
    std::vector<std::unique_ptr<EnumDeclaration>> enum_members;
    std::vector<std::unique_ptr<InterfaceMemberMethod>> method_members;
};

struct StructMember {
    StructMember(std::unique_ptr<Type> type,
                      std::unique_ptr<Identifier> identifier,
                      std::unique_ptr<Constant> maybe_default_value)
        : type(std::move(type)),
          identifier(std::move(identifier)),
          maybe_default_value(std::move(maybe_default_value)) {}

    std::unique_ptr<Type> type;
    std::unique_ptr<Identifier> identifier;
    std::unique_ptr<Constant> maybe_default_value;
};

struct StructDeclaration {
    StructDeclaration(std::unique_ptr<Identifier> identifier,
                      std::vector<std::unique_ptr<ConstDeclaration>> const_members,
                      std::vector<std::unique_ptr<EnumDeclaration>> enum_members,
                      std::vector<std::unique_ptr<StructMember>> members)
        : identifier(std::move(identifier)),
          const_members(std::move(const_members)),
          enum_members(std::move(enum_members)),
          members(std::move(members)) {}

    std::unique_ptr<Identifier> identifier;
    std::vector<std::unique_ptr<ConstDeclaration>> const_members;
    std::vector<std::unique_ptr<EnumDeclaration>> enum_members;
    std::vector<std::unique_ptr<StructMember>> members;
};

struct UnionMember {
    UnionMember(std::unique_ptr<Type> type,
                std::unique_ptr<Identifier> identifier)
        : type(std::move(type)),
          identifier(std::move(identifier)) {}

    std::unique_ptr<Type> type;
    std::unique_ptr<Identifier> identifier;
};

struct UnionDeclaration {
    UnionDeclaration(std::unique_ptr<Identifier> identifier,
                     std::vector<std::unique_ptr<ConstDeclaration>> const_members,
                     std::vector<std::unique_ptr<EnumDeclaration>> enum_members,
                     std::vector<std::unique_ptr<UnionMember>> members)
        : identifier(std::move(identifier)),
          const_members(std::move(const_members)),
          enum_members(std::move(enum_members)),
          members(std::move(members)) {}

    std::unique_ptr<Identifier> identifier;
    std::vector<std::unique_ptr<ConstDeclaration>> const_members;
    std::vector<std::unique_ptr<EnumDeclaration>> enum_members;
    std::vector<std::unique_ptr<UnionMember>> members;
};

struct File {
    File(std::unique_ptr<CompoundIdentifier> identifier,
         std::vector<std::unique_ptr<Using>> using_list,
         std::vector<std::unique_ptr<ConstDeclaration>> const_declaration_list,
         std::vector<std::unique_ptr<EnumDeclaration>> enum_declaration_list,
         std::vector<std::unique_ptr<InterfaceDeclaration>> interface_declaration_list,
         std::vector<std::unique_ptr<StructDeclaration>> struct_declaration_list,
         std::vector<std::unique_ptr<UnionDeclaration>> union_declaration_list)
        : identifier(std::move(identifier)),
          using_list(std::move(using_list)),
          const_declaration_list(std::move(const_declaration_list)),
          enum_declaration_list(std::move(enum_declaration_list)),
          interface_declaration_list(std::move(interface_declaration_list)),
          struct_declaration_list(std::move(struct_declaration_list)),
          union_declaration_list(std::move(union_declaration_list)) {}

    std::unique_ptr<CompoundIdentifier> identifier;
    std::vector<std::unique_ptr<Using>> using_list;
    std::vector<std::unique_ptr<ConstDeclaration>> const_declaration_list;
    std::vector<std::unique_ptr<EnumDeclaration>> enum_declaration_list;
    std::vector<std::unique_ptr<InterfaceDeclaration>> interface_declaration_list;
    std::vector<std::unique_ptr<StructDeclaration>> struct_declaration_list;
    std::vector<std::unique_ptr<UnionDeclaration>> union_declaration_list;
};

} // namespace fidl