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

library test.fidlcodec.examples;

protocol Echo {
    EchoString(string:100? value) -> (string:100? response);
};

protocol FidlCodecTestInterface {
    Empty();
    String(string:100 s);
    Bool(bool b);
    Int8(int8 i8);
    Int16(int16 i16);
    Int32(int32 i32);
    Int64(int64 i64);
    Uint8(uint8 ui8);
    Uint16(uint16 ui16);
    Uint32(uint32 ui32);
    Uint64(uint64 ui64);
    Float32(float32 f32);
    Float64(float64 f64);

    Complex(int32 real, int32 imaginary);
    StringInt(string:100 s, int32 i32);

    Array1(array<int32>:1 b_1);
    Array2(array<int32>:2 b_2);
    Vector(vector<int32>:10? v_1);

    TwoStringArrayInt(array<string:100>:2 arr, int32 i32);
    TwoStringVectorInt(vector<string:100>:10 vec, int32 i32);
    TwoStringVectors(vector<string:100>:10 v_1, vector<string:100>:10 v_2);
    VectorUint8(vector<uint8>:100 v);
    VectorUint32(vector<uint32>:100 v);
    VectorStruct(vector<SmallStruct>:100 v);
    ArrayStruct(array<SmallStruct>:3 a);
    VectorStruct2(vector<SmallUnevenStruct>:100 v);
    ArrayStruct2(array<SmallUnevenStruct>:3 a);

    Struct(PrimitiveTypes p);
    BoolStruct(BoolStructType s);
    NullableStruct(PrimitiveTypes? p);
    NullableStructAndInt(PrimitiveTypes? p, int32 i);
    ArrayNullableStruct(array<TwoStringStruct?>:3 a);

    SmallStructAfterByte(uint8 u, SmallStruct s1, SmallStruct s2);

    TwoStringStructInt(TwoStringStruct s, int32 i32);
    TwoStringNullableStructInt(TwoStringStruct? s, int32 i32);

    Union(IntStructUnion isu, int32 i);
    NullableUnion(IntStructUnion? isu, int32 i);
    NullableUnionIntFirst(int32 i, IntStructUnion? isu);
    ArrayNullableUnion(array<IntStructUnion?>:3 a);

    XUnion(IntStructXunion isu, int32 i);
    NullableXUnion(IntStructXunion? isu, int32 i);
    NullableXUnionIntFirst(int32 i, IntStructXunion? isu);

    ShortUnion(U8U16Union u, int32 i);
    ShortXUnion(U8U16Xunion u, int32 i);

    U8U16UnionStruct(U8U16UnionStructType s);

    DefaultEnumMessage(DefaultEnum ev);
    I8EnumMessage(I8Enum ev);
    I16EnumMessage(I16Enum ev);
    I32EnumMessage(I32Enum ev);
    I64EnumMessage(I64Enum ev);

    DefaultBitsMessage(DefaultBits v);
    I8BitsMessage(I8Bits v);
    I16BitsMessage(I16Bits v);
    I32BitsMessage(I32Bits v);
    I64BitsMessage(I64Bits v);

    Table(ValueTable table, int32 i);

    Handle(handle<channel> ch);
    NullableHandle(handle<channel>? ch);
    HandleStructMessage(HandleStruct hs);
    HandleTableMessage(HandleTable t);
    TraversalOrderMessage(TraversalOrder t);

    Protocol(ParamProtocol ch);
};

struct BoolStructType {
    bool b;
};

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

struct SmallStruct {
    uint8 a;
    uint8 b;
    uint8 c;
};

struct SmallUnevenStruct {
    uint32 a;
    uint8 b;
};

struct TwoStringStruct {
    string:100 value1;
    string:100 value2;
};

union IntStructUnion {
    1: int32 variant_i;
    2: TwoStringStruct variant_tss;
};

xunion IntStructXunion {
    int32 variant_i;
    TwoStringStruct variant_tss;
};

union U8U16Union {
    1: uint8 variant_u8;
    2: uint16 variant_u16;
};

xunion U8U16Xunion {
    uint8 variant_u8;
    uint16 variant_u16;
};

struct U8U16UnionStructType {
    U8U16Union u;
};

enum DefaultEnum {
    X = 23;
};

enum I8Enum : int8 {
    X = -23;
};

enum I16Enum : int16 {
    X = -23;
};

enum I32Enum : int32 {
    X = -23;
};

enum I64Enum : int64 {
    X = -23;
};

bits DefaultBits {
    A = 1;
    B = 2;
    C = 4;
    D = 8;
};

bits I8Bits : uint8 {
    A = 1;
    B = 2;
    C = 4;
    D = 8;
};

bits I16Bits : uint16 {
    A = 0x100;
    B = 0x200;
    C = 0x400;
    D = 0x800;
};

bits I32Bits : uint64 {
    A = 0x10000;
    B = 0x20000;
    C = 0x40000;
    D = 0x80000;
};

bits I64Bits : uint64 {
    A = 0x100000000;
    B = 0x200000000;
    C = 0x400000000;
    D = 0x800000000;
};

table ValueTable {
    1: int16 first_int16;
    2: TwoStringStruct second_struct;
    3: IntStructUnion third_union;
};

struct HandleStruct {
    handle<channel> h1;
    handle<channel> h2;
    handle<channel> h3;
};

struct OptHandleStruct {
    handle<channel>? sh1;
    handle<channel>? sh2;
};

table HandleTable {
    1: handle<channel> h1;
    2: OptHandleStruct s1;
};

struct TraversalOrder {
    OptHandleStruct? s;
    handle<channel>? h1;
    handle<channel>? h2;
};

[FragileBase]
protocol ParamProtocol {
    Method();
};