// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file is autogenerated by:
//     mojo/public/tools/bindings/mojom_bindings_generator.py
// For:
//     mojom/echo.mojom
//

package echo

import (
	"fmt"
	"mojo/public/go/bindings"
	"mojo/public/go/system"
	"sort"
)

type Echo interface {
	EchoString(inValue *string) (outValue *string, err error)
}

var echo_Name = "mojo::examples::Echo"

type Echo_Request bindings.InterfaceRequest

func (r *Echo_Request) Name() string {
	return echo_Name
}

type Echo_Pointer bindings.InterfacePointer

func (p *Echo_Pointer) Name() string {
	return echo_Name
}

type Echo_ServiceFactory struct{
	Delegate Echo_Factory
}

type Echo_Factory interface {
	Create(request Echo_Request)
}

func (f *Echo_ServiceFactory) Name() string {
	return echo_Name
}

func (f *Echo_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
	request := Echo_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
	f.Delegate.Create(request)
}

// CreateMessagePipeForEcho creates a message pipe for use with the
// Echo interface with a Echo_Request on one end and a Echo_Pointer on the other.
func CreateMessagePipeForEcho() (Echo_Request, Echo_Pointer) {
        r, p := bindings.CreateMessagePipeForMojoInterface()
        return Echo_Request(r), Echo_Pointer(p)
}

const echo_EchoString_Name uint32 = 0

type Echo_Proxy struct {
	router *bindings.Router
	ids bindings.Counter
}

func NewEchoProxy(p Echo_Pointer, waiter bindings.AsyncWaiter) *Echo_Proxy {
	return &Echo_Proxy{
		bindings.NewRouter(p.PassMessagePipe(), waiter),
		bindings.NewCounter(),
	}
}

func (p *Echo_Proxy) Close_Proxy() {
	p.router.Close()
}

type echo_EchoString_Params struct {
	inValue *string
}

func (s *echo_EchoString_Params) Encode(encoder *bindings.Encoder) error {
	encoder.StartStruct(8, 0)
	if s.inValue == nil {
		encoder.WriteNullPointer()
	} else {
		if err := encoder.WritePointer(); err != nil {
			return err
		}
		if err := encoder.WriteString((*s.inValue)); err != nil {
			return err
		}
	}
	if err := encoder.Finish(); err != nil {
		return err
	}
	return nil
}

var echo_EchoString_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
	bindings.DataHeader{16, 0},
}

func (s *echo_EchoString_Params) Decode(decoder *bindings.Decoder) error {
	header, err := decoder.StartStruct()
	if err != nil {
		return err
	}
	index := sort.Search(len(echo_EchoString_Params_Versions), func(i int) bool {
		return echo_EchoString_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
	})
	if index < len(echo_EchoString_Params_Versions) {
		if echo_EchoString_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
			index--
		}
		expectedSize := echo_EchoString_Params_Versions[index].Size
		if expectedSize != header.Size {
			return &bindings.ValidationError{bindings.UnexpectedStructHeader,
				fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
			}
		}
	}
	if header.ElementsOrVersion >= 0 {
		pointer0, err := decoder.ReadPointer()
		if err != nil {
			return err
		}
		if pointer0 == 0 {
			s.inValue = nil
		} else {
			s.inValue = new(string)
			value0, err := decoder.ReadString()
			if err != nil {
				return err
			}
			(*s.inValue) = value0
		}
	}
	if err := decoder.Finish(); err != nil {
		return err
	}
	return nil
}

type echo_EchoString_ResponseParams struct {
	outValue *string
}

func (s *echo_EchoString_ResponseParams) Encode(encoder *bindings.Encoder) error {
	encoder.StartStruct(8, 0)
	if s.outValue == nil {
		encoder.WriteNullPointer()
	} else {
		if err := encoder.WritePointer(); err != nil {
			return err
		}
		if err := encoder.WriteString((*s.outValue)); err != nil {
			return err
		}
	}
	if err := encoder.Finish(); err != nil {
		return err
	}
	return nil
}

var echo_EchoString_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
	bindings.DataHeader{16, 0},
}

func (s *echo_EchoString_ResponseParams) Decode(decoder *bindings.Decoder) error {
	header, err := decoder.StartStruct()
	if err != nil {
		return err
	}
	index := sort.Search(len(echo_EchoString_ResponseParams_Versions), func(i int) bool {
		return echo_EchoString_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
	})
	if index < len(echo_EchoString_ResponseParams_Versions) {
		if echo_EchoString_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
			index--
		}
		expectedSize := echo_EchoString_ResponseParams_Versions[index].Size
		if expectedSize != header.Size {
			return &bindings.ValidationError{bindings.UnexpectedStructHeader,
				fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
			}
		}
	}
	if header.ElementsOrVersion >= 0 {
		pointer0, err := decoder.ReadPointer()
		if err != nil {
			return err
		}
		if pointer0 == 0 {
			s.outValue = nil
		} else {
			s.outValue = new(string)
			value0, err := decoder.ReadString()
			if err != nil {
				return err
			}
			(*s.outValue) = value0
		}
	}
	if err := decoder.Finish(); err != nil {
		return err
	}
	return nil
}

func (p *Echo_Proxy) EchoString(inValue *string) (outValue *string, err error) {
	payload := &echo_EchoString_Params{
		inValue,
	}
	header := bindings.MessageHeader{
		Type: echo_EchoString_Name,
		Flags: bindings.MessageExpectsResponseFlag,
		RequestId: p.ids.Count(),
	}
	var message *bindings.Message
	if message, err = bindings.EncodeMessage(header, payload); err != nil {
		err = fmt.Errorf("can't encode request: %v", err.Error())
		p.Close_Proxy()
		return
	}
	readResult := <-p.router.AcceptWithResponse(message)
	if err = readResult.Error; err != nil {
		p.Close_Proxy()
		return
	}
	if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag {
		err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
			fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags),
		}
		return
	}
	if got, want := readResult.Message.Header.Type, echo_EchoString_Name; got != want {
		err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
			fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
		}
		return
	}
	var response echo_EchoString_ResponseParams
	if err = readResult.Message.DecodePayload(&response); err != nil {
		p.Close_Proxy()
		return
	}
	outValue = response.outValue
	return
}

type echo_Stub struct {
	connector *bindings.Connector
	impl Echo
}

func NewEchoStub(r Echo_Request, impl Echo, waiter bindings.AsyncWaiter) *bindings.Stub {
	connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
	return bindings.NewStub(connector, &echo_Stub{connector, impl})
}

func (s *echo_Stub) Accept(message *bindings.Message) (err error) {
	switch message.Header.Type {
	case echo_EchoString_Name:
		if message.Header.Flags != bindings.MessageExpectsResponseFlag {
			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
			}
		}
		var request echo_EchoString_Params
		if err := message.DecodePayload(&request); err != nil {
			return err
		}
		var response echo_EchoString_ResponseParams
		response.outValue, err = s.impl.EchoString(request.inValue)
		if err != nil {
			return
		}
		header := bindings.MessageHeader{
			Type: echo_EchoString_Name,
			Flags: bindings.MessageIsResponseFlag,
			RequestId: message.Header.RequestId,
		}
		message, err = bindings.EncodeMessage(header, &response)
		if err != nil {
			return err
		}
		return s.connector.WriteMessage(message)
	default:
		return &bindings.ValidationError{
			bindings.MessageHeaderUnknownMethod,
			fmt.Sprintf("unknown method %v", message.Header.Type),
		}
	}
	return
}