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

library fidl.test.compatibility;

struct this_is_a_struct {
    string s;
};

struct this_is_an_empty_struct {
};

union this_is_a_union {
    1: string s;
    2: bool b;
};

table this_is_a_table {
    1: string s;
};

flexible union this_is_a_xunion {
    1: string s;
    2: bool b;
};

struct primitive_types {
    bool b;
    int8 i8;
    int16 i16;
    int32 i32;
    int64 i64;
    uint8 u8;
    uint16 u16;
    uint32 u32;
    uint64 u64;
    float32 f32;
    float64 f64;
};

struct default_values {
    bool b1 = true;
    bool b2 = false;
    int8 i8 = -23;
    int16 i16 = 34;
    int32 i32 = -34595;
    int64 i64 = 3948038;
    uint8 u8 = 0;
    uint16 u16 = 348;
    uint32 u32 = 9038;
    uint64 u64 = 19835;
    float32 f32 = 1.30;
    float64 f64 = 0.0000054;
    string s = "hello";
};

// Arbitrary, but must be small enough such that a single message doesn't exceed
// kMaxMessageSize or kMaxMessageHandles.
const uint32 arrays_size = 3;

struct arrays {
    array<bool>:1 b_0;
    array<int8>:1 i8_0;
    array<int16>:1 i16_0;
    array<int32>:1 i32_0;
    array<int64>:1 i64_0;
    array<uint8>:1 u8_0;
    array<uint16>:1 u16_0;
    array<uint32>:1 u32_0;
    array<uint64>:1 u64_0;
    array<float32>:1 f32_0;
    array<float64>:1 f64_0;
    array<handle>:1 handle_0;
    array<bool>:arrays_size b_1;
    array<int8>:arrays_size i8_1;
    array<int16>:arrays_size i16_1;
    array<int32>:arrays_size i32_1;
    array<int64>:arrays_size i64_1;
    array<uint8>:arrays_size u8_1;
    array<uint16>:arrays_size u16_1;
    array<uint32>:arrays_size u32_1;
    array<uint64>:arrays_size u64_1;
    array<float32>:arrays_size f32_1;
    array<float64>:arrays_size f64_1;
    array<handle>:arrays_size handle_1;
};

struct arrays_2d {
    array<array<bool>:2>:arrays_size b;
    array<array<int8>:2>:arrays_size i8;
    array<array<int16>:2>:arrays_size i16;
    array<array<int32>:2>:arrays_size i32;
    array<array<int64>:2>:arrays_size i64;
    array<array<uint8>:2>:arrays_size u8;
    array<array<uint16>:2>:arrays_size u16;
    array<array<uint32>:2>:arrays_size u32;
    array<array<uint64>:2>:arrays_size u64;
    array<array<float32>:2>:arrays_size f32;
    array<array<float64>:2>:arrays_size f64;
    array<array<handle>:2>:arrays_size handle_handle;
};

// Arbitrary, but must be small enough such that a single message doesn't exceed
// kMaxMessageSize or kMaxMessageHandles.
const uint32 vectors_size = 3;

struct vectors {
    vector<bool> b_0;
    vector<int8> i8_0;
    vector<int16> i16_0;
    vector<int32> i32_0;
    vector<int64> i64_0;
    vector<uint8> u8_0;
    vector<uint16> u16_0;
    vector<uint32> u32_0;
    vector<uint64> u64_0;
    vector<float32> f32_0;
    vector<float64> f64_0;
    vector<handle> handle_0;
    vector<vector<bool>:2> b_1;
    vector<vector<int8>:2> i8_1;
    vector<vector<int16>:2> i16_1;
    vector<vector<int32>:2> i32_1;
    vector<vector<int64>:2> i64_1;
    vector<vector<uint8>:2> u8_1;
    vector<vector<uint16>:2> u16_1;
    vector<vector<uint32>:2> u32_1;
    vector<vector<uint64>:2> u64_1;
    vector<vector<float32>:2> f32_1;
    vector<vector<float64>:2> f64_1;
    vector<vector<handle>:2> handle_1;
    vector<bool>:1 b_sized_0;
    vector<int8>:1 i8_sized_0;
    vector<int16>:1 i16_sized_0;
    vector<int32>:1 i32_sized_0;
    vector<int64>:1 i64_sized_0;
    vector<uint8>:1 u8_sized_0;
    vector<uint16>:1 u16_sized_0;
    vector<uint32>:1 u32_sized_0;
    vector<uint64>:1 u64_sized_0;
    vector<float32>:1 f32_sized_0;
    vector<float64>:1 f64_sized_0;
    vector<handle>:1 handle_sized_0;
    vector<bool>:vectors_size b_sized_1;
    vector<int8>:vectors_size i8_sized_1;
    vector<int16>:vectors_size i16_sized_1;
    vector<int32>:vectors_size i32_sized_1;
    vector<int64>:vectors_size i64_sized_1;
    vector<uint8>:vectors_size u8_sized_1;
    vector<uint16>:vectors_size u16_sized_1;
    vector<uint32>:vectors_size u32_sized_1;
    vector<uint64>:vectors_size u64_sized_1;
    vector<float32>:vectors_size f32_sized_1;
    vector<float64>:vectors_size f64_sized_1;
    vector<handle>:vectors_size handle_sized_1;
    vector<vector<bool>:2>:vectors_size b_sized_2;
    vector<vector<int8>:2>:vectors_size i8_sized_2;
    vector<vector<int16>:2>:vectors_size i16_sized_2;
    vector<vector<int32>:2>:vectors_size i32_sized_2;
    vector<vector<int64>:2>:vectors_size i64_sized_2;
    vector<vector<uint8>:2>:vectors_size u8_sized_2;
    vector<vector<uint16>:2>:vectors_size u16_sized_2;
    vector<vector<uint32>:2>:vectors_size u32_sized_2;
    vector<vector<uint64>:2>:vectors_size u64_sized_2;
    vector<vector<float32>:2>:vectors_size f32_sized_2;
    vector<vector<float64>:2>:vectors_size f64_sized_2;
    vector<vector<handle>:2>:vectors_size handle_sized_2;
    vector<bool>:1? b_nullable_0;
    vector<int8>:1? i8_nullable_0;
    vector<int16>:1? i16_nullable_0;
    vector<int32>:1? i32_nullable_0;
    vector<int64>:1? i64_nullable_0;
    vector<uint8>:1? u8_nullable_0;
    vector<uint16>:1? u16_nullable_0;
    vector<uint32>:1? u32_nullable_0;
    vector<uint64>:1? u64_nullable_0;
    vector<float32>:1? f32_nullable_0;
    vector<float64>:1? f64_nullable_0;
    vector<handle>:1? handle_nullable_0;
    vector<vector<bool>:2>? b_nullable_1;
    vector<vector<int8>:2>? i8_nullable_1;
    vector<vector<int16>:2>? i16_nullable_1;
    vector<vector<int32>:2>? i32_nullable_1;
    vector<vector<int64>:2>? i64_nullable_1;
    vector<vector<uint8>:2>? u8_nullable_1;
    vector<vector<uint16>:2>? u16_nullable_1;
    vector<vector<uint32>:2>? u32_nullable_1;
    vector<vector<uint64>:2>? u64_nullable_1;
    vector<vector<float32>:2>? f32_nullable_1;
    vector<vector<float64>:2>? f64_nullable_1;
    vector<vector<handle>:2>? handle_nullable_1;
    vector<bool>:1? b_nullable_sized_0;
    vector<int8>:1? i8_nullable_sized_0;
    vector<int16>:1? i16_nullable_sized_0;
    vector<int32>:1? i32_nullable_sized_0;
    vector<int64>:1? i64_nullable_sized_0;
    vector<uint8>:1? u8_nullable_sized_0;
    vector<uint16>:1? u16_nullable_sized_0;
    vector<uint32>:1? u32_nullable_sized_0;
    vector<uint64>:1? u64_nullable_sized_0;
    vector<float32>:1? f32_nullable_sized_0;
    vector<float64>:1? f64_nullable_sized_0;
    vector<handle>:1? handle_nullable_sized_0;
    vector<bool>:vectors_size? b_nullable_sized_1;
    vector<int8>:vectors_size? i8_nullable_sized_1;
    vector<int16>:vectors_size? i16_nullable_sized_1;
    vector<int32>:vectors_size? i32_nullable_sized_1;
    vector<int64>:vectors_size? i64_nullable_sized_1;
    vector<uint8>:vectors_size? u8_nullable_sized_1;
    vector<uint16>:vectors_size? u16_nullable_sized_1;
    vector<uint32>:vectors_size? u32_nullable_sized_1;
    vector<uint64>:vectors_size? u64_nullable_sized_1;
    vector<float32>:vectors_size? f32_nullable_sized_1;
    vector<float64>:vectors_size? f64_nullable_sized_1;
    vector<handle>:vectors_size? handle_nullable_sized_1;
    vector<vector<bool>:2>:vectors_size? b_nullable_sized_2;
    vector<vector<int8>:2>:vectors_size? i8_nullable_sized_2;
    vector<vector<int16>:2>:vectors_size? i16_nullable_sized_2;
    vector<vector<int32>:2>:vectors_size? i32_nullable_sized_2;
    vector<vector<int64>:2>:vectors_size? i64_nullable_sized_2;
    vector<vector<uint8>:2>:vectors_size? u8_nullable_sized_2;
    vector<vector<uint16>:2>:vectors_size? u16_nullable_sized_2;
    vector<vector<uint32>:2>:vectors_size? u32_nullable_sized_2;
    vector<vector<uint64>:2>:vectors_size? u64_nullable_sized_2;
    vector<vector<float32>:2>:vectors_size? f32_nullable_sized_2;
    vector<vector<float64>:2>:vectors_size? f64_nullable_sized_2;
    vector<vector<handle>:2>:vectors_size? handle_nullable_sized_2;
};

// We don't test handle types that don't support duplication
// (supports_duplication in zx/object_traits.h) or that require special
// privileges to create.
struct handles {
    handle handle_handle;
    handle<process> process_handle;
    handle<thread> thread_handle;
    handle<vmo> vmo_handle;
    handle<event> event_handle;
    handle<port> port_handle;
    handle<socket> socket_handle;
    handle<eventpair> eventpair_handle;
    handle<job> job_handle;
    handle<vmar> vmar_handle;
    handle<fifo> fifo_handle;
    handle<timer> timer_handle;
    handle? nullable_handle_handle;
    handle<process>? nullable_process_handle;
    handle<thread>? nullable_thread_handle;
    handle<vmo>? nullable_vmo_handle;
    handle<channel>? nullable_channel_handle;
    handle<event>? nullable_event_handle;
    handle<port>? nullable_port_handle;
    handle<interrupt>? nullable_interrupt_handle;
    handle<debuglog>? nullable_log_handle;
    handle<socket>? nullable_socket_handle;
    handle<eventpair>? nullable_eventpair_handle;
    handle<job>? nullable_job_handle;
    handle<vmar>? nullable_vmar_handle;
    handle<fifo>? nullable_fifo_handle;
    handle<timer>? nullable_timer_handle;
};

// Arbitrary.
const uint32 strings_size = 32;

struct strings {
    string s;
    string? nullable_s;
    string:2 size_0_s;
    string:strings_size size_1_s;
    string:2? nullable_size_0_s;
    string:strings_size? nullable_size_1_s;
};

enum default_enum {
    kZero = 0;
    kOne = 1;
};

enum i8_enum : int8 {
    kNegativeOne = -1;
    kOne = 1;
};

enum i16_enum : int16 {
    kNegativeOne = -1;
    kOne = 1;
    kTwo = 2;
};

enum i32_enum : int32 {
    kNegativeOne = -1;
    kOne = 1;
    kTwo = 2;
    kThree = 3;
};

enum i64_enum : int64 {
    kNegativeOne = -1;
    kOne = 1;
    kTwo = 2;
    kThree = 3;
    kFour = 4;
};

enum u8_enum : uint8 {
    kOne = 1;
    kTwo = 2;
    kThree = 3;
    kFour = 4;
    kFive = 5;
};

enum u16_enum : uint16 {
    kOne = 1;
    kTwo = 2;
    kThree = 3;
    kFour = 4;
    kFive = 5;
    kSix = 6;
};

enum u32_enum : uint32 {
    kOne = 1;
    kTwo = 2;
    kThree = 3;
    kFour = 4;
    kFive = 5;
    kSix = 6;
    kSeven = 7;
};

enum u64_enum : uint64 {
    kOne = 1;
    kTwo = 2;
    kThree = 3;
    kFour = 4;
    kFive = 5;
    kSix = 6;
    kSeven = 7;
    kEight = 8;
};

bits default_bits {
    kOne = 1;
    kTwo = 2;
};

bits u8_bits : uint8 {
    kOne = 1;
    kTwo = 2;
    kThree = 4;
    kFour = 8;
    kFive = 16;
};

bits u16_bits : uint16 {
    kOne = 1;
    kTwo = 2;
    kThree = 4;
    kFour = 8;
    kFive = 16;
    kSix = 32;
};

bits u32_bits : uint32 {
    kOne = 1;
    kTwo = 2;
    kThree = 4;
    kFour = 8;
    kFive = 16;
    kSix = 32;
    kSeven = 64;
};

bits u64_bits : uint64 {
    kOne = 1;
    kTwo = 2;
    kThree = 4;
    kFour = 8;
    kFive = 16;
    kSix = 32;
    kSeven = 64;
    kEight = 128;
};

struct structs {
    this_is_a_struct s;
    this_is_a_struct? nullable_s;
    this_is_an_empty_struct es;
};

struct unions {
    this_is_a_union u;
    this_is_a_union? nullable_u;
};

// This struct is meant to exercise almost all features of FIDL.
struct Struct {
    primitive_types primitive_types;
    default_values default_values;
    arrays arrays;
    arrays_2d arrays_2d;
    vectors vectors;
    handles handles;
    strings strings;
    default_enum default_enum;
    i8_enum i8_enum;
    i16_enum i16_enum;
    i32_enum i32_enum;
    i64_enum i64_enum;
    u8_enum u8_enum;
    u16_enum u16_enum;
    u32_enum u32_enum;
    u64_enum u64_enum;
    default_bits default_bits;
    u8_bits u8_bits;
    u16_bits u16_bits;
    u32_bits u32_bits;
    u64_bits u64_bits;
    structs structs;
    unions unions;
    this_is_a_table table;
    this_is_a_xunion xunion;
    bool b;
};

// This struct contains arrays of all different kinds of FIDL types.
struct ArraysStruct {
    array<bool>:arrays_size bools;
    array<int8>:arrays_size int8s;
    array<int16>:arrays_size int16s;
    array<int32>:arrays_size int32s;
    array<int64>:arrays_size int64s;
    array<uint8>:arrays_size uint8s;
    array<uint16>:arrays_size uint16s;
    array<uint32>:arrays_size uint32s;
    array<uint64>:arrays_size uint64s;
    array<float32>:arrays_size float32s;
    array<float64>:arrays_size float64s;
    array<default_enum>:arrays_size enums;
    array<default_bits>:arrays_size bits;
    array<handle>:arrays_size handles;
    array<handle?>:arrays_size nullable_handles;
    array<string>:arrays_size strings;
    array<string?>:arrays_size nullable_strings;
    array<this_is_a_struct>:arrays_size structs;
    array<this_is_a_struct?>:arrays_size nullable_structs;
    array<this_is_a_union>:arrays_size unions;
    array<this_is_a_union?>:arrays_size nullable_unions;
    array<array<uint32>:arrays_size>:arrays_size arrays;
    array<vector<uint32>>:arrays_size vectors;
    array<vector<uint32>?>:arrays_size nullable_vectors;
    array<this_is_a_table>:arrays_size tables;
    array<this_is_a_xunion>:arrays_size xunions;
};

// This struct contains vectors of all different kinds of FIDL types.
struct VectorsStruct {
    vector<bool>:vectors_size bools;
    vector<int8>:vectors_size int8s;
    vector<int16>:vectors_size int16s;
    vector<int32>:vectors_size int32s;
    vector<int64>:vectors_size int64s;
    vector<uint8>:vectors_size uint8s;
    vector<uint16>:vectors_size uint16s;
    vector<uint32>:vectors_size uint32s;
    vector<uint64>:vectors_size uint64s;
    vector<float32>:vectors_size float32s;
    vector<float64>:vectors_size float64s;
    vector<default_enum>:vectors_size enums;
    vector<default_bits>:vectors_size bits;
    vector<handle>:vectors_size handles;
    vector<handle?>:vectors_size nullable_handles;
    vector<string>:vectors_size strings;
    vector<string?>:vectors_size nullable_strings;
    vector<this_is_a_struct>:vectors_size structs;
    vector<this_is_a_struct?>:vectors_size nullable_structs;
    vector<this_is_a_union>:vectors_size unions;
    vector<this_is_a_union?>:vectors_size nullable_unions;
    vector<array<uint32>:vectors_size>:vectors_size arrays;
    vector<vector<uint32>>:vectors_size vectors;
    vector<vector<uint32>?>:vectors_size nullable_vectors;
    vector<this_is_a_table>:vectors_size tables;
    vector<this_is_a_xunion>:vectors_size xunions;
};

// This table has members all different FIDL types.
table AllTypesTable {
    1: bool bool_member;
    2: int8 int8_member;
    3: int16 int16_member;
    4: int32 int32_member;
    5: int64 int64_member;
    6: uint8 uint8_member;
    7: uint16 uint16_member;
    8: uint32 uint32_member;
    9: uint64 uint64_member;
    10: float32 float32_member;
    11: float64 float64_member;
    12: default_enum enum_member;
    13: default_bits bits_member;
    14: handle handle_member;
    15: string string_member;
    16: this_is_a_struct struct_member;
    17: this_is_a_union union_member;
    18: array<uint32>:arrays_size array_member;
    19: vector<uint32> vector_member;
    20: this_is_a_table table_member;
    21: this_is_a_xunion xunion_member;
};

// This xunion has members all different FIDL types.
flexible union AllTypesXunion {
     1: bool bool_member;
     2: int8 int8_member;
     3: int16 int16_member;
     4: int32 int32_member;
     5: int64 int64_member;
     6: uint8 uint8_member;
     7: uint16 uint16_member;
     8: uint32 uint32_member;
     9: uint64 uint64_member;
    10: float32 float32_member;
    11: float64 float64_member;
    12: default_enum enum_member;
    13: default_bits bits_member;
    14: handle handle_member;
    15: string string_member;
    16: this_is_a_struct struct_member;
    17: this_is_a_union union_member;
    18: array<uint32>:arrays_size array_member;
    19: vector<uint32> vector_member;
    20: this_is_a_table table_member;
    21: this_is_a_xunion xunion_member;
};

enum RespondWith {
    SUCCESS = 1;
    ERR = 2;
};

[Discoverable]
protocol Echo {
    // If `forward_to_server` is empty, just returns `value`.
    // If `forward_to_server` is not empty, it is treated as the URL of a server
    // which implements this interface. The server that recieves the non-empty
    // `forward_to_server` arg acts as a proxy for that other server.
    // For the error variants: if should_error is true, the provided err result
    // error is sent, otherwise the response variant is sent.
    EchoStruct(Struct value, string forward_to_server) -> (Struct value);
    EchoStructWithError(
        Struct value, default_enum result_err, string forward_to_server, RespondWith result_variant)
        -> (Struct value) error default_enum;

    // Same as the above, but the server should use the event to return the
    // response, rather than a return value.
    EchoStructNoRetVal(Struct value, string forward_to_server);
    -> EchoEvent(Struct value);
    EchoArrays(ArraysStruct value, string forward_to_server) -> (ArraysStruct value);
    EchoArraysWithError(
        ArraysStruct value, default_enum result_err, string forward_to_server, RespondWith result_variant)
        -> (ArraysStruct value) error default_enum;

    EchoVectors(VectorsStruct value, string forward_to_server) -> (VectorsStruct value);
    EchoVectorsWithError(
        VectorsStruct value, default_enum result_err, string forward_to_server, RespondWith result_variant)
        -> (VectorsStruct value) error default_enum;

    EchoTable(AllTypesTable value, string forward_to_server) -> (AllTypesTable value);
    EchoTableWithError(
        AllTypesTable value, default_enum result_err, string forward_to_server, RespondWith result_variant)
        -> (AllTypesTable value) error default_enum;

    EchoXunions(vector<AllTypesXunion> value, string forward_to_server) -> (vector<AllTypesXunion> value);
    EchoXunionsWithError(
        vector<AllTypesXunion> value, default_enum result_err, string forward_to_server, RespondWith result_variant)
        -> (vector<AllTypesXunion> value) error default_enum;
};