// Copyright (c) 2010 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.

#ifndef REMOTING_PROTOCOL_MESSAGE_READER_H_
#define REMOTING_PROTOCOL_MESSAGE_READER_H_

#include "base/callback.h"
#include "base/ref_counted.h"
#include "base/scoped_ptr.h"
#include "base/task.h"
#include "net/base/completion_callback.h"
#include "net/base/io_buffer.h"
#include "remoting/protocol/message_decoder.h"

namespace net {
class Socket;
}  // namespace net

namespace remoting {
namespace protocol {

class MessageReader;

namespace internal {

template <class T>
class MessageReaderPrivate {
 private:
  friend class remoting::protocol::MessageReader;

  typedef typename Callback1<T*>::Type MessageReceivedCallback;

  MessageReaderPrivate(MessageReceivedCallback* callback)
      : message_received_callback_(callback) {
  }

  ~MessageReaderPrivate() { }

  void OnDataReceived(net::IOBuffer* buffer, int data_size) {
    typedef typename std::list<T*>::iterator MessageListIterator;

    std::list<T*> message_list;
    message_decoder_.ParseMessages(buffer, data_size, &message_list);
    for (MessageListIterator it = message_list.begin();
         it != message_list.end(); ++it) {
      message_received_callback_->Run(*it);
    }
  }

  void Destroy() {
    delete this;
  }

  // Message decoder is used to decode bytes into protobuf message.
  MessageDecoder message_decoder_;

  // Callback is called when a message is received.
  scoped_ptr<MessageReceivedCallback> message_received_callback_;
};

}  // namespace internal

// MessageReader reads data from the socket asynchronously and uses
// MessageReaderPrivate to decode the data received.
class MessageReader {
 public:
  MessageReader();
  virtual ~MessageReader();

  // Stops reading. Must be called on the same thread as Init().
  void Close();

  // Initialize the MessageReader with a socket. If a message is received
  // |callback| is called.
  template <class T>
  void Init(net::Socket* socket, typename Callback1<T*>::Type* callback) {
    internal::MessageReaderPrivate<T>* reader =
        new internal::MessageReaderPrivate<T>(callback);
    data_received_callback_.reset(
        ::NewCallback(
            reader, &internal::MessageReaderPrivate<T>::OnDataReceived));
    destruction_callback_.reset(
        ::NewCallback(reader, &internal::MessageReaderPrivate<T>::Destroy));
    Init(socket);
  }

 private:
  void Init(net::Socket* socket);

  void DoRead();
  void OnRead(int result);
  void HandleReadResult(int result);

  net::Socket* socket_;

  bool closed_;
  scoped_refptr<net::IOBuffer> read_buffer_;
  net::CompletionCallbackImpl<MessageReader> read_callback_;

  scoped_ptr<Callback2<net::IOBuffer*, int>::Type> data_received_callback_;
  scoped_ptr<Callback0::Type> destruction_callback_;
};

}  // namespace protocol
}  // namespace remoting

#endif  // REMOTING_PROTOCOL_MESSAGE_READER_H_