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

import itertools
import sys

import mojo_system
from mojo_bindings import promise

class DataPipeCopyException(Exception):
  def __init__(self, *args, **kwargs):
    Exception.__init__(self, *args, **kwargs)
    self.__traceback__ = sys.exc_info()[2]


def CopyFromDataPipe(data_pipe, deadline):
  """
  Returns a Promise that operates as follows:
  - If |data_pipe| is successfully read from, the promise resolves with the
    bytes that were read.
  - Otherwise, the promise rejects with an exception whose message contains the
    status from the attempted read.
  """
  class DataPipeCopyHelper():
    def __init__(self, data_pipe, deadline, resolve, reject):
      self.data_pipe = data_pipe
      self.original_deadline = deadline
      self.start_time = mojo_system.GetTimeTicksNow()
      self.resolve = resolve
      self.reject = reject
      self.buffer_size = 1024
      self.data = bytearray(self.buffer_size)
      self.index = 0

    def _ComputeCurrentDeadline(self):
      if self.original_deadline == mojo_system.DEADLINE_INDEFINITE:
        return self.original_deadline
      elapsed_time = mojo_system.GetTimeTicksNow() - self.start_time
      return max(0, self.original_deadline - elapsed_time)

    def CopyFromDataPipeAsync(self, result):
      while result == mojo_system.RESULT_OK:
        assert self.index <= len(self.data)
        if self.index == len(self.data):
          self.buffer_size *= 2
          self.data.extend(itertools.repeat(0, self.buffer_size))

        # Careful! Have to construct a memoryview object here as otherwise the
        # slice operation will create a copy of |data| and hence not write into
        # |data| as desired.
        result, read_bytes = self.data_pipe.ReadData(
            memoryview(self.data)[self.index:])
        if read_bytes:
          self.index += len(read_bytes)
        del read_bytes

      if result == mojo_system.RESULT_SHOULD_WAIT:
        data_pipe.AsyncWait(mojo_system.HANDLE_SIGNAL_READABLE,
                            self._ComputeCurrentDeadline(),
                            self.CopyFromDataPipeAsync)
        return

      # Treat a failed precondition as EOF.
      if result == mojo_system.RESULT_FAILED_PRECONDITION:
        self.resolve(self.data[:self.index])
        return

      self.reject(DataPipeCopyException("Result: %d" % result))


  def GenerationMethod(resolve, reject):
    helper = DataPipeCopyHelper(data_pipe, deadline, resolve, reject)
    helper.CopyFromDataPipeAsync(mojo_system.RESULT_OK)

  return promise.Promise(GenerationMethod)