#undef DEBUG
/*
* TclOutputStream.java
*
* Copyright (c) 2003 Mo DeJong
*
* See the file "license.terms" for information on usage and
* redistribution of this file, and for a DISCLAIMER OF ALL
* WARRANTIES.
* 
* Included in SQLite3 port to C# for use in testharness only;  2008 Noah B Hart
*
* RCS @(#) $Id: TclOutputStream.java,v 1.1 2003/03/08 03:42:44 mdejong Exp $
*/

// A TclOutputStream is a cross between a Java OutputStream and
// a Writer. The class supports writing raw bytes as well as
// encoded characters.
using System;
using System.IO;
using System.Text;

namespace tcl.lang
{

  public class TclOutputStream
  {
    internal System.Text.Encoding Encoding
    {
      set
      {
        encoding = value;
      }

    }
    internal char EofChar
    {
      set
      {
        eofChar = value;
      }

    }
    internal int Translation
    {
      set
      {
        translation = value;
      }

    }
    public int Buffering
    {
      set
      {
        buffering = value;
      }

    }
    public int BufferSize
    {
      set
      {
        bufSize = value;
        outputStage = null;
      }

    }
    public bool Blocking
    {
      set
      {
        blocking = value;
      }

    }
    public bool Blocked
    {
      get
      {
        return blocked;
      }

    }
    /// <summary> Tcl_OutputBuffered -> getNumBufferedBytes
    /// 
    /// Return the number of bytes that are current buffered.
    /// </summary>
    internal int NumBufferedBytes
    {


      get
      {
        ChannelBuffer buf;
        int IOQueued = 0;
        for ( buf = outQueueHead; buf != null; buf = buf.next )
        {
          IOQueued += buf.nextAdded - buf.nextRemoved;
        }
        if ( ( curOut != null ) && ( curOut.nextAdded > curOut.nextRemoved ) )
        {
          //bufferReady = true;
          IOQueued += curOut.nextAdded - curOut.nextRemoved;
        }
        return IOQueued;
      }

    }

    /// <summary> The Java byte stream object data will be written to.</summary>

    private Stream output;

    /// <summary> If nonzero, use this character as EOF marker.</summary>

    private char eofChar;

    /// <summary> Translation mode for end-of-line character</summary>

    protected internal int translation;

    /// <summary> Name of Java encoding for this Channel.
    /// A null value means use no encoding (binary).
    /// </summary>

    protected internal System.Text.Encoding encoding;

    /// <summary> Current converter object. A null value means
    /// that no conversions have been done yet.
    /// </summary>

    protected internal Encoder ctb = null;

    /// <summary> Buffering</summary>

    protected internal int buffering;

    /// <summary> Blocking</summary>

    protected internal bool blocking;

    /// <summary> Blocked</summary>

    protected internal bool blocked = false;

    /// <summary> Buffer size in bytes</summary>

    protected internal int bufSize;

    /// <summary> Staging area used to store chars before conversion into
    /// buffered bytes.
    /// </summary>

    protected internal char[] outputStage = null;

    /// <summary> Flags used to track encoding states.
    /// The encodingState member of called outputEncodingState
    /// in the C ChannelState type. The encodingStart and encodingEnd
    /// members combined are called outputEncodingFlags
    /// and have the bit values TCL_ENCODING_END and TCL_ENCODING_START.
    /// </summary>

    internal Object encodingState = null;
    internal bool encodingStart = true;
    internal bool encodingEnd = false;

    /// <summary> First and last buffers in the output queue and
    /// the current buffer being filled.
    /// </summary>

    internal ChannelBuffer outQueueHead = null;
    internal ChannelBuffer outQueueTail = null;
    internal ChannelBuffer curOut = null;


    /// <summary> Used to track buffer state, these are bit flags stored
    /// in the flags filed in the C impl.
    /// </summary>

    protected internal bool bufferReady = false;
    protected internal bool bgFlushScheduled = false;
    protected internal bool closed = false;

    /// <summary> Posix error code of deferred error.</summary>
    protected internal int unreportedError = 0;

    /// <summary> FIXME: add desc</summary>

    protected internal int refCount = 0;

    /// <summary> Constructor for Tcl input stream class. We require
    /// a byte stream source at init time, the stram can't
    /// be changed after the TclInputStream is created.
    /// </summary>

    internal TclOutputStream( Stream inOutput )
    {
      output = inOutput;
    }

    /// <summary> Tcl_Close -> close
    /// 
    /// Closes a channel.
    /// 
    /// Closes the channel if this is the last reference.
    /// 
    /// close removes the channel as far as the user is concerned.
    /// However, it may continue to exist for a while longer if it has
    /// a background flush scheduled. The device itself is eventually
    /// closed and the channel record removed, in closeChannel.
    /// </summary>

    internal void close()
    {
      //CloseCallback *cbPtr;
      //Channel *chanPtr;
      //ChannelState *statePtr;
      int result;

      // Perform special handling for standard channels being closed. If the
      // refCount is now 1 it means that the last reference to the standard
      // channel is being explicitly closed, so bump the refCount down
      // artificially to 0. This will ensure that the channel is actually
      // closed, below. Also set the static pointer to NULL for the channel.

      //CheckForStdChannelsBeingClosed();

      // This operation should occur at the top of a channel stack.

      //chanPtr = (Channel *) chan;
      //statePtr = chanPtr->state;
      //chanPtr = statePtr->topChanPtr;

      if ( refCount > 0 )
      {
        throw new TclRuntimeError( "called Tcl_Close on channel with refCount > 0" );
      }

      // When the channel has an escape sequence driven encoding such as
      // iso2022, the terminated escape sequence must write to the buffer.

      if ( ( (System.Object)encoding != null ) && ( curOut != null ) )
      {
        encodingEnd = true;
        // FIXME : Make sure this flushes the CharToByteConverter
        char[] empty = new char[0];
        writeChars( empty, 0, 0 );
      }

      // FIXME: Impl channel close callbacks ???
      //Tcl_ClearChannelHandlers(chan);

      // Invoke the registered close callbacks and delete their records.

      //while (statePtr->closeCbPtr != (CloseCallback *) NULL) {
      //    cbPtr = statePtr->closeCbPtr;
      //    statePtr->closeCbPtr = cbPtr->nextPtr;
      //    (cbPtr.proc) (cbPtr->clientData);
      //    ckfree((char *) cbPtr);
      //}

      // Ensure that the last output buffer will be flushed.

      if ( ( curOut != null ) && ( curOut.nextAdded > curOut.nextRemoved ) )
      {
        bufferReady = true;
      }

      // If this channel supports it, close the read side, since we don't need it
      // anymore and this will help avoid deadlocks on some channel types.

      //if (chanPtr->typePtr->closeProc == TCL_CLOSE2PROC) {
      //    result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, interp,
      //            TCL_CLOSE_READ);
      //} else {
      //    result = 0;
      //}
      result = 0;

      // The call to flushChannel will flush any queued output and invoke
      // the close function of the channel driver, or it will set up the
      // channel to be flushed and closed asynchronously.

      closed = true;
      if ( ( flushChannel( null, false ) != 0 ) || ( result != 0 ) )
      {
        // FIXME: We should raise a TclPosixException here instead
        //return TCL.TCL_ERROR;
        throw new IOException( "Exception in flushChannel" );
      }
    }

    /// <summary> CloseChannel -> closeChannel
    /// 
    /// Utility procedure to close a channel and free associated resources.
    /// 
    /// If the channel was stacked, then the it will copy the necessary
    /// elements of the NEXT channel into the TOP channel, in essence
    /// unstacking the channel.  The NEXT channel will then be freed.
    /// 
    /// If the channel was not stacked, then we will free all the bits
    /// for the TOP channel, including the data structure itself.
    /// 
    /// Returns 1 if the channel was stacked, 0 otherwise.
    /// </summary>

    protected internal int closeChannel( Interp interp, int errorCode )
    {
      int result = 0;
      //ChannelState *statePtr;		// state of the channel stack.
      //ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

      //if (chanPtr == NULL) {
      //    return result;
      //}
      //statePtr = chanPtr->state;

      // Discard a leftover buffer in the current output buffer field.

      if ( curOut != null )
      {
        //ckfree((char *) statePtr->curOutPtr);
        curOut = null;
      }

      // The caller guarantees that there are no more buffers
      // queued for output.

      if ( outQueueHead != null )
      {
        throw new TclRuntimeError( "TclFlush, closed channel: queued output left" );
      }

      // If the EOF character is set in the channel, append that to the
      // output device.

      if ( eofChar != 0 )
      {
        try
        {
          output.WriteByte( (byte)eofChar );
        }
        catch ( IOException ex )
        {
          // FIXME: How can we recover here??
          SupportClass.WriteStackTrace( ex, Console.Error );
        }
      }

      // Remove this channel from of the list of all channels.

      //Tcl_CutChannel((Tcl_Channel) chanPtr);

      // Close and free the channel driver state.

      //if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
      //    result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData, interp);
      //} else {
      //    result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, interp,
      //            0);
      //}

      // Some resources can be cleared only if the bottom channel
      // in a stack is closed. All the other channels in the stack
      // are not allowed to remove.

      //if (chanPtr == statePtr->bottomChanPtr) {
      //    if (statePtr->channelName != (char *) NULL) {
      //        ckfree((char *) statePtr->channelName);
      //        statePtr->channelName = NULL;
      //    }

      //    Tcl_FreeEncoding(statePtr->encoding);
      //    if (statePtr->outputStage != NULL) {
      //        ckfree((char *) statePtr->outputStage);
      //       statePtr->outputStage = (char *) NULL;
      //    }
      //}

      // If we are being called synchronously, report either
      // any latent error on the channel or the current error.

      if ( unreportedError != 0 )
      {
        errorCode = unreportedError;
      }
      if ( errorCode == 0 )
      {
        errorCode = result;
        if ( errorCode != 0 )
        {
          // FIXME: How can we deal with this errno issue?
          //Tcl_SetErrno(errorCode);
        }
      }

      // Cancel any outstanding timer.

      //Tcl_DeleteTimerHandler(statePtr->timer);

      // Mark the channel as deleted by clearing the type structure.

      //if (chanPtr->downChanPtr != (Channel *) NULL) {
      //    Channel *downChanPtr = chanPtr->downChanPtr;

      //    statePtr->nextCSPtr	= tsdPtr->firstCSPtr;
      //    tsdPtr->firstCSPtr = statePtr;

      //    statePtr->topChanPtr = downChanPtr;
      //    downChanPtr->upChanPtr = (Channel *) NULL;
      //    chanPtr->typePtr = NULL;

      //    Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);
      //    return Tcl_Close(interp, (Tcl_Channel) downChanPtr);
      //}

      // There is only the TOP Channel, so we free the remaining
      // pointers we have and then ourselves.  Since this is the
      // last of the channels in the stack, make sure to free the
      // ChannelState structure associated with it.  We use
      // Tcl_EventuallyFree to allow for any last

      //chanPtr->typePtr = NULL;

      //Tcl_EventuallyFree((ClientData) statePtr, TCL_DYNAMIC);
      //Tcl_EventuallyFree((ClientData) chanPtr, TCL_DYNAMIC);

      return errorCode;
    }

    /// <summary> Tcl_Flush -> flush
    /// 
    /// Flushes output data on a channel.
    /// </summary>

    internal void flush()
    {
      // Force current output buffer to be output also.

      if ( ( curOut != null ) && ( curOut.nextAdded > curOut.nextRemoved ) )
      {
        bufferReady = true;
      }

      int result = flushChannel( null, false );
      if ( result != 0 )
      {
        // FIXME: Should we throw an exception here?
        throw new IOException( "Exception during flushChannel" );
      }
      // ATK .NET has own buffer also we need to Flush the
      // IO.Stream too
      output.Flush();
    }

    /// <summary> FlushChannel -> flushChannel
    /// 
    /// This function flushes as much of the queued output as is possible
    /// now. If calledFromAsyncFlush is true, it is being called in an
    /// event handler to flush channel output asynchronously.
    /// 
    /// Return 0 if successful, else the error code that was returned by the
    /// channel type operation.
    /// 
    /// May produce output on a channel. May block indefinitely if the
    /// channel is synchronous. May schedule an async flush on the channel.
    /// May recycle memory for buffers in the output queue.
    /// 
    /// </summary>
    /// <param name="interp">                Interp object.
    /// </param>
    /// <param name="calledFromAsyncFlush">  True if called from an asynchronous
    /// flush callback.
    /// </param>

    internal int flushChannel( Interp interp, bool calledFromAsyncFlush )
    {
      //ChannelState *statePtr = chanPtr->state;
      ChannelBuffer buf;
      int toWrite; // Amount of output data in current
      // buffer available to be written.
      int written; // Amount of output data actually
      // written in current round.
      int errorCode = 0; // Stores POSIX error codes from
      // channel driver operations.
      bool wroteSome = false; // Set to true if any data was
      // written to the driver.

      // Prevent writing on a dead channel -- a channel that has been closed
      // but not yet deallocated. This can occur if the exit handler for the
      // channel deallocation runs before all channels are deregistered in
      // all interpreters.

      //if (CheckForDeadChannel(interp, statePtr)) return -1;

      // Loop over the queued buffers and attempt to flush as
      // much as possible of the queued output to the channel.

      while ( true )
      {
        // If the queue is empty and there is a ready current buffer, OR if
        // the current buffer is full, then move the current buffer to the
        // queue.

        if ( ( ( curOut != null ) && ( curOut.nextAdded == curOut.bufLength ) ) || ( bufferReady && ( outQueueHead == null ) ) )
        {
          bufferReady = false;
          curOut.next = null;
          if ( outQueueHead == null )
          {
            outQueueHead = curOut;
          }
          else
          {
            outQueueTail.next = curOut;
          }
          outQueueTail = curOut;
          curOut = null;
        }
        buf = outQueueHead;

        // If we are not being called from an async flush and an async
        // flush is active, we just return without producing any output.

        if ( ( !calledFromAsyncFlush ) && bgFlushScheduled )
        {
          return 0;
        }

        // If the output queue is still empty, break out of the while loop.

        if ( buf == null )
        {
          break; // Out of the "while (1)".
        }

        // Produce the output on the channel.

        toWrite = buf.nextAdded - buf.nextRemoved;
        //written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData,
        //        bufPtr->buf + bufPtr->nextRemoved, toWrite,
        //        &errorCode);
        try
        {
          output.Write( buf.buf, buf.nextRemoved, toWrite );
          written = toWrite;
        }
        catch ( IOException ex )
        {
          // FIXME: How can we recover and get posix errors?
          SupportClass.WriteStackTrace( ex, System.Console.Error );
          errorCode = TclPosixException.EIO; // Generic I/O error ???
          written = -1;
        }

        // If the write failed completely attempt to start the asynchronous
        // flush mechanism and break out of this loop - do not attempt to
        // write any more output at this time.

        if ( written < 0 )
        {
          // If the last attempt to write was interrupted, simply retry.

          if ( errorCode == TclPosixException.EINTR )
          {
            errorCode = 0;
            continue;
          }

          // If the channel is non-blocking and we would have blocked,
          // start a background flushing handler and break out of the loop.

          if ( ( errorCode == TclPosixException.EWOULDBLOCK ) || ( errorCode == TclPosixException.EAGAIN ) )
          {
            // This used to check for CHANNEL_NONBLOCKING, and panic
            // if the channel was blocking.  However, it appears
            // that setting stdin to -blocking 0 has some effect on
            // the stdout when it's a tty channel (dup'ed underneath)

            if ( !bgFlushScheduled )
            {
              bgFlushScheduled = true;
              updateInterest();
            }
            errorCode = 0;
            break;
          }

          // Decide whether to report the error upwards or defer it.

          if ( calledFromAsyncFlush )
          {
            if ( unreportedError == 0 )
            {
              unreportedError = errorCode;
            }
          }
          else
          {
            // FIXME: Need to figure out what to do here!
            //Tcl_SetErrno(errorCode);
            //if (interp != NULL) {
            //    // Casting away CONST here is safe because the
            //    // TCL_VOLATILE flag guarantees CONST treatment
            //    // of the Posix error string.
            //    Tcl_SetResult(interp,
            //            (char *) Tcl_PosixError(interp), TCL_VOLATILE);
          }

          // When we get an error we throw away all the output
          // currently queued.

          discardQueued();
          continue;
        }
        else
        {
          wroteSome = true;
        }

        buf.nextRemoved += written;

        // If this buffer is now empty, recycle it.

        if ( buf.nextRemoved == buf.nextAdded )
        {
          outQueueHead = buf.next;
          if ( outQueueHead == null )
          {
            outQueueTail = null;
          }
          recycleBuffer( buf, false );
        }
      } // Closes "while (1)".

      // If we wrote some data while flushing in the background, we are done.
      // We can't finish the background flush until we run out of data and
      // the channel becomes writable again.  This ensures that all of the
      // pending data has been flushed at the system level.

      if ( bgFlushScheduled )
      {
        if ( wroteSome )
        {
          return errorCode;
        }
        else if ( outQueueHead == null )
        {
          bgFlushScheduled = false;
          // FIXME: What is this watchProc?
          //(chanPtr->typePtr->watchProc)(chanPtr->instanceData,
          //        statePtr->interestMask);
        }
      }

      // If the channel is flagged as closed, delete it when the refCount
      // drops to zero, the output queue is empty and there is no output
      // in the current output buffer.

      if ( closed && ( refCount <= 0 ) && ( outQueueHead == null ) && ( ( curOut == null ) || ( curOut.nextAdded == curOut.nextRemoved ) ) )
      {
        return closeChannel( interp, errorCode );
      }
      return errorCode;
    }

    // Helper class to implement integer pass by reference.

    public class IntPtr
    {
      private void InitBlock( TclOutputStream enclosingInstance )
      {
        this.enclosingInstance = enclosingInstance;
      }
      private TclOutputStream enclosingInstance;
      public TclOutputStream Enclosing_Instance
      {
        get
        {
          return enclosingInstance;
        }

      }
      internal int i;

      internal IntPtr( TclOutputStream enclosingInstance )
      {
        InitBlock( enclosingInstance );
      }

      internal IntPtr( TclOutputStream enclosingInstance, int value )
      {
        InitBlock( enclosingInstance );
        i = value;
      }
    }

    /// <summary> RecycleBuffer -> recycleBuffer
    /// 
    /// Helper function to recycle output buffers. Ensures that
    /// that curOut is set to a buffer. Only if these conditions
    /// are met is the buffer released so that it can be
    /// garbage collected.
    /// </summary>

    private void recycleBuffer( ChannelBuffer buf, bool mustDiscard )
    {

      if ( mustDiscard )
        return;

      // Only save buffers which are at least as big as the requested
      // buffersize for the channel. This is to honor dynamic changes
      // of the buffersize made by the user.

      if ( ( buf.bufLength - tcl.lang.ChannelBuffer.BUFFER_PADDING ) < bufSize )
      {
        return;
      }

      if ( curOut == null )
      {
        curOut = buf;
        buf.nextRemoved = tcl.lang.ChannelBuffer.BUFFER_PADDING;
        buf.nextAdded = tcl.lang.ChannelBuffer.BUFFER_PADDING;
        buf.next = null;
      }
    }

    /// <summary> DiscardOutputQueued -> discardQueued
    /// 
    /// Discards all output queued in the output queue of a channel.
    /// </summary>

    private void discardQueued()
    {
      ChannelBuffer buf;

      while ( outQueueHead != null )
      {
        buf = outQueueHead;
        outQueueHead = buf.next;
        recycleBuffer( buf, false );
      }
      outQueueHead = null;
      outQueueTail = null;
    }

    /// <summary> UpdateInterest -> updateInterest
    /// 
    /// Arrange for the notifier to call us back at appropriate times
    /// based on the current state of the channel.
    /// </summary>

    internal void updateInterest()
    {
      // FIXME: Currently unimplemented
    }

    /// <summary> seekCheckBuferReady
    /// 
    /// This method is used by the seek command to check
    /// the channel for buffered output and mark the
    /// buffer as ready to flush if found.
    /// </summary>

    internal void seekCheckBuferReady()
    {
      if ( ( curOut != null ) && ( curOut.nextAdded > curOut.nextRemoved ) )
      {
        bufferReady = true;
      }
    }

    /// <summary> TranslateOutputEOL -> translateEOL
    /// 
    /// Helper function for writeBytes() and writeChars().  Converts the
    /// '\n' characters in the source buffer into the appropriate EOL
    /// form specified by the output translation mode.
    /// 
    /// EOL translation stops either when the source buffer is empty
    /// or the output buffer is full.
    /// 
    /// When converting to CRLF mode and there is only 1 byte left in
    /// the output buffer, this routine stores the '\r' in the last
    /// byte and then stores the '\n' in the byte just past the end of the 
    /// buffer.  The caller is responsible for passing in a buffer that
    /// is large enough to hold the extra byte.
    /// 
    /// Results:
    /// 
    /// The return value is 1 if a '\n' was translated from the source
    /// buffer, or 0 otherwise -- this can be used by the caller to
    /// decide to flush a line-based channel even though the channel
    /// buffer is not full.
    /// 
    /// dstLenPtr.i is filled with how many bytes of the output buffer
    /// were used.  As mentioned above, this can be one more that
    /// the output buffer's specified length if a CRLF was stored.
    /// 
    /// srcLenPtr.i is filled with how many bytes of the source buffer
    /// were consumed.
    /// 
    /// It may be obvious, but bears mentioning that when converting
    /// in CRLF mode (which requires two bytes of storage in the output
    /// buffer), the number of bytes consumed from the source buffer
    /// will be less than the number of bytes stored in the output buffer.
    /// 
    /// </summary>
    /// <param name="dstArray,">Output buffer to fill with translated bytes or chars.
    /// </param>
    /// <param name="dstStart,">First unused index in the dst output array.
    /// </param>
    /// <param name="srcArray,">Input buffer that holds the bytes or chars to translate
    /// </param>
    /// <param name="srcStart,">Index of first available byte in src array.
    /// </param>
    /// <param name="dstLenPtr,">On entry, the maximum length of output
    /// buffer in bytes or chars.  On exit, the number of
    /// bytes or chars actually used in output buffer.
    /// </param>
    /// <param name="srcLenPtr,">On entry, the length of source buffer.
    /// On exit, the number of bytes or chars read from
    /// the source buffer.
    /// </param>

    internal bool translateEOL( System.Object dstArray, int dstStart, Object srcArray, int srcStart, IntPtr dstLenPtr, IntPtr srcLenPtr )
    {

      // Figure out if the srcArray and dstArray buffers
      // are byte or char arrays.
      bool isCharType;
      char[] srcArrayChar, dstArrayChar;
      byte[] srcArrayByte, dstArrayByte;

      if ( ( srcArray is char[] ) && ( dstArray is char[] ) )
      {
        isCharType = true;
        srcArrayChar = (char[])srcArray;
        dstArrayChar = (char[])dstArray;
        srcArrayByte = null;
        dstArrayByte = null;
      }
      else if ( ( srcArray is byte[] ) && ( dstArray is byte[] ) )
      {
        isCharType = false;
        srcArrayChar = null;
        dstArrayChar = null;
        srcArrayByte = (byte[])srcArray;
        dstArrayByte = (byte[])dstArray;
      }
      else
      {
        throw new TclRuntimeError( "unknown array argument types" );
      }

      int src, dst, dstEnd, srcLen;
      bool newlineFound;

      src = srcStart;
      dst = dstStart;
      newlineFound = false;
      srcLen = srcLenPtr.i;

      switch ( translation )
      {

        case TclIO.TRANS_LF:
          {
            if ( isCharType )
            {
              for ( dstEnd = dst + srcLen; dst < dstEnd; )
              {
                if ( srcArrayChar[src] == '\n' )
                {
                  newlineFound = true;
                }
                dstArrayChar[dst++] = srcArrayChar[src++];
              }
            }
            else
            {
              for ( dstEnd = dst + srcLen; dst < dstEnd; )
              {
                if ( srcArrayByte[src] == '\n' )
                {
                  newlineFound = true;
                }
                dstArrayByte[dst++] = srcArrayByte[src++];
              }
            }
            dstLenPtr.i = srcLen;
            break;
          }

        case TclIO.TRANS_CR:
          {
            if ( isCharType )
            {
              for ( dstEnd = dst + srcLen; dst < dstEnd; )
              {
                if ( srcArrayChar[src] == '\n' )
                {
                  dstArrayChar[dst++] = '\r';
                  newlineFound = true;
                  src++;
                }
                else
                {
                  dstArrayChar[dst++] = srcArrayChar[src++];
                }
              }
            }
            else
            {
              for ( dstEnd = dst + srcLen; dst < dstEnd; )
              {
                if ( srcArrayByte[src] == '\n' )
                {
                  dstArrayByte[dst++] = (byte)SupportClass.Identity( '\r' );
                  newlineFound = true;
                  src++;
                }
                else
                {
                  dstArrayByte[dst++] = srcArrayByte[src++];
                }
              }
            }
            dstLenPtr.i = srcLen;
            break;
          }

        case TclIO.TRANS_CRLF:
          {
            // Since this causes the number of bytes to grow, we
            // start off trying to put 'srcLen' bytes into the
            // output buffer, but allow it to store more bytes, as
            // long as there's still source bytes and room in the
            // output buffer.

            int dstMax;
            //int dstStart, srcStart;

            //dstStart = dst;
            dstMax = dst + dstLenPtr.i;

            //srcStart = src;

            if ( srcLen < dstLenPtr.i )
            {
              dstEnd = dst + srcLen;
            }
            else
            {
              dstEnd = dst + dstLenPtr.i;
            }

            if ( isCharType )
            {
              while ( dst < dstEnd )
              {
                if ( srcArrayChar[src] == '\n' )
                {
                  if ( dstEnd < dstMax )
                  {
                    dstEnd++;
                  }
                  dstArrayChar[dst++] = '\r';
                  newlineFound = true;
                }
                dstArrayChar[dst++] = srcArrayChar[src++];
              }
            }
            else
            {
              while ( dst < dstEnd )
              {
                if ( srcArrayByte[src] == '\n' )
                {
                  if ( dstEnd < dstMax )
                  {
                    dstEnd++;
                  }
                  dstArrayByte[dst++] = (byte)SupportClass.Identity( '\r' );
                  newlineFound = true;
                }
                dstArrayByte[dst++] = srcArrayByte[src++];
              }
            }

            srcLenPtr.i = src - srcStart;
            dstLenPtr.i = dst - dstStart;
            break;
          }

        default:
          {
            break;
          }

      }
      return newlineFound;
    }

    /// <summary> Tcl_UtfToExternal -> unicodeToExternal
    /// 
    /// Convert a source buffer from unicode characters to a specified encoding.
    /// 
    /// FIXME: Add doc for return values
    /// 
    /// </summary>
    /// <param name="src,">        Source characters.
    /// </param>
    /// <param name="srcOff,">     First index in src input array.
    /// </param>
    /// <param name="srcLen,">     Number of characters in src buffer.
    /// </param>
    /// <param name="dst,">        Array to store encoded bytes in.
    /// </param>
    /// <param name="dstOff,">     First available index in dst array.
    /// </param>
    /// <param name="dstLen,">     Length of dst array.
    /// </param>
    /// <param name="srcReadPtr,"> Filled with the number of characters from
    /// the source string that were converted.
    /// This may be less than the original source
    /// length if there was a problem converting
    /// some source characters.
    /// </param>
    /// <param name="dstWrotePtr,">Filled with the number of bytes that were
    /// stored in the output buffer as a result of
    /// the conversion
    /// </param>
    /// <param name="dstCharsPtr,">Filled with the number of characters that
    /// correspond to the bytes stored in the
    /// output buffer.
    /// </param>

    internal int unicodeToExternal( char[] src, int srcOff, int srcLen, byte[] dst, int dstOff, int dstLen, IntPtr srcReadPtr, IntPtr dstWrotePtr, IntPtr dstCharsPtr )
    {
      bool debug;
      int result;

      if ( (System.Object)encoding == null )
      {
        throw new TclRuntimeError( "unicodeToExternal called with null encoding" );
      }

      if ( srcLen == 0 )
      {
        srcReadPtr.i = 0;
        if ( dstWrotePtr != null )
          dstWrotePtr.i = 0;
        if ( dstCharsPtr != null )
          dstCharsPtr.i = 0;
        return 0;
      }

#if DEBUG
			System.Diagnostics.Debug.WriteLine("now to encode char array of length " + srcLen);
				System.Diagnostics.Debug.WriteLine("srcOff is " + srcOff);
				for (int i = srcOff; i < (srcOff + srcLen); i++)
				{
					System.Diagnostics.Debug.WriteLine("(char) '" + src[i] + "'");
				}
				System.Diagnostics.Debug.WriteLine("encoded as " + encoding);
#endif

      if ( ctb == null )
      {
        try
        {
          ctb = this.encoding.GetEncoder();
        }
        catch ( IOException ex )
        {
          // Valid encodings should be checked already
          throw new TclRuntimeError( "unsupported encoding \"" + encoding + "\"" );
        }
      }

      int chars_read, bytes_written;

      int required_bytes = ctb.GetByteCount( src, srcOff, srcLen, false );
      // ATK do not allow buffer overflow by decresing read bytes count
      if ( required_bytes > dstLen )
      {
        srcLen = dstLen;
      }
      bytes_written = ctb.GetBytes( src, srcOff, srcLen, dst, dstOff, false );
      srcReadPtr.i = srcLen;
      if ( dstWrotePtr != null )
        dstWrotePtr.i = bytes_written;
      if ( dstCharsPtr != null )
        dstCharsPtr.i = srcLen;

      // FIXME: When do we return error codes?
      result = 0;

      return result;
    }

    /// <summary> WriteBytes -> writeBytes
    /// 
    /// Write a sequence of bytes into an output buffer, may queue the
    /// buffer for output if it gets full, and also remembers whether the
    /// current buffer is ready e.g. if it contains a newline and we are in
    /// line buffering mode.
    /// 
    /// The number of bytes written or -1 in case of error. If -1,
    /// Tcl_GetErrno will return the error code.
    /// 
    /// May buffer up output and may cause output to be produced on the
    /// channel.
    /// 
    /// </summary>
    /// <param name="src">         Bytes to write.
    /// </param>
    /// <param name="srfOff">      First index in src array.
    /// </param>
    /// <param name="srfLen">      Number of bytes to write.
    /// </param>

    internal int writeBytes( byte[] srcArray, int srcOff, int srcLen )
    {
      ChannelBuffer buf;
      byte[] dstArray;
      int dst, src, dstMax, sawLF, total, savedLF;
      IntPtr dstLen = new IntPtr( this );
      IntPtr toWrite = new IntPtr( this );

      total = 0;
      sawLF = 0;
      savedLF = 0;
      src = srcOff;

      // Loop over all bytes in src, storing them in output buffer with
      // proper EOL translation.

      while ( srcLen + savedLF > 0 )
      {
        buf = curOut;
        if ( buf == null )
        {
          buf = new ChannelBuffer( bufSize );
          curOut = buf;
        }
        //dst = bufPtr->buf + bufPtr->nextAdded;
        dstArray = buf.buf;
        dst = buf.nextAdded;
        dstMax = buf.bufLength - buf.nextAdded;
        dstLen.i = dstMax;

        toWrite.i = dstLen.i;
        if ( toWrite.i > srcLen )
        {
          toWrite.i = srcLen;
        }

        if ( savedLF != 0 )
        {
          // A '\n' was left over from last call to translateEOL()
          // and we need to store it in this buffer.  If the channel is
          // line-based, we will need to flush it.

          dstArray[dst++] = (byte)SupportClass.Identity( '\n' );
          dstLen.i--;
          sawLF++;
        }
        if ( translateEOL( dstArray, dst, srcArray, src, dstLen, toWrite ) )
        {
          sawLF++;
        }
        dstLen.i += savedLF;
        savedLF = 0;

        if ( dstLen.i > dstMax )
        {
          savedLF = 1;
          dstLen.i = dstMax;
        }
        buf.nextAdded += dstLen.i;
        if ( checkFlush( buf, ( sawLF != 0 ) ) != 0 )
        {
          return -1;
        }
        total += dstLen.i;
        src += toWrite.i;
        srcLen -= toWrite.i;
        sawLF = 0;
      }
      return total;
    }

    /// <summary> CheckFlush -> checkFlush
    /// 
    /// Helper function for writeBytes() and writeChars().  If the
    /// channel buffer is ready to be flushed, flush it.
    /// 
    /// The return value is -1 if there was a problem flushing the
    /// channel buffer, or 0 otherwise.
    /// 
    /// The buffer will be recycled if it is flushed.
    /// 
    /// </summary>
    /// <param name="buf">         Channel buffer to possibly flush.
    /// </param>
    /// <param name="newlineFlag"> True if a the channel buffer
    /// contains a newline.
    /// </param>

    internal int checkFlush( ChannelBuffer buf, bool newlineFlag )
    {
      // The current buffer is ready for output:
      // 1. if it is full.
      // 2. if it contains a newline and this channel is line-buffered.
      // 3. if it contains any output and this channel is unbuffered.

      if ( !bufferReady )
      {
        if ( buf.nextAdded == buf.bufLength )
        {
          bufferReady = true;
        }
        else if ( buffering == TclIO.BUFF_LINE )
        {
          if ( newlineFlag )
          {
            bufferReady = true;
          }
        }
        else if ( buffering == TclIO.BUFF_NONE )
        {
          bufferReady = true;
        }
      }
      if ( bufferReady )
      {
        if ( flushChannel( null, false ) != 0 )
        {
          return -1;
        }
      }
      return 0;
    }

    /// <summary> WriteChars -> writeChars
    /// 
    /// Convert chars to the channel's external encoding and
    /// write the produced bytes into an output buffer, may queue the
    /// buffer for output if it gets full, and also remembers whether the
    /// current buffer is ready e.g. if it contains a newline and we are in
    /// line buffering mode.
    /// 
    /// The number of bytes written or -1 in case of error. If -1,
    /// Tcl_GetErrno will return the error code.
    /// 
    /// May buffer up output and may cause output to be produced on the
    /// channel.
    /// 
    /// </summary>
    /// <param name="src">         Chars to write.
    /// </param>
    /// <param name="srfOff">      First index in src array.
    /// </param>
    /// <param name="srfLen">      Number of chars to write.
    /// </param>

    internal int writeChars( char[] srcArray, int srcOff, int srcLen )
    {
      //ChannelState *statePtr = chanPtr->state;	// state info for channel
      ChannelBuffer buf;
      char[] stageArray;
      byte[] dstArray;
      int stage, src, dst;
      int saved, savedLF, sawLF, total, dstLen, stageMax;
      int endEncoding, result;
      bool consumedSomething;
      //Tcl_Encoding encoding;
      byte[] safe = new byte[ChannelBuffer.BUFFER_PADDING];
      IntPtr stageLen = new IntPtr( this );
      IntPtr toWrite = new IntPtr( this );
      IntPtr stageRead = new IntPtr( this );
      IntPtr dstWrote = new IntPtr( this );

      total = 0;
      sawLF = 0;
      savedLF = 0;
      saved = 0;
      //encoding = statePtr->encoding;
      src = 0;

      // Write the terminated escape sequence even if srcLen is 0.

      endEncoding = ( encodingEnd ? 0 : 1 );

      // Loop over all characters in src, storing them in staging buffer
      // with proper EOL translation.

      consumedSomething = true;
      while ( consumedSomething && ( srcLen + savedLF + endEncoding > 0 ) )
      {
        consumedSomething = false;
        if ( outputStage == null )
        {
          outputStage = new char[bufSize + 2];
        }
        stageArray = outputStage;
        stage = 0;
        stageMax = bufSize;
        stageLen.i = stageMax;

        toWrite.i = stageLen.i;
        if ( toWrite.i > srcLen )
        {
          toWrite.i = srcLen;
        }

        if ( savedLF != 0 )
        {
          // A '\n' was left over from last call to TranslateOutputEOL()
          // and we need to store it in the staging buffer.  If the
          // channel is line-based, we will need to flush the output
          // buffer (after translating the staging buffer).

          stageArray[stage++] = '\n';
          stageLen.i--;
          sawLF++;
        }
        if ( translateEOL( stageArray, stage, srcArray, src, stageLen, toWrite ) )
        {
          sawLF++;
        }

        stage -= savedLF;
        stageLen.i += savedLF;
        savedLF = 0;

        if ( stageLen.i > stageMax )
        {
          savedLF = 1;
          stageLen.i = stageMax;
        }
        src += toWrite.i;
        srcLen -= toWrite.i;

        // Loop over all characters in staging buffer, converting them
        // to external encoding, storing them in output buffer.

        while ( stageLen.i + saved + endEncoding > 0 )
        {
          buf = curOut;
          if ( buf == null )
          {
            buf = new ChannelBuffer( bufSize );
            curOut = buf;
          }
          // dst = buf.buf + buf.nextAdded;
          dstArray = buf.buf;
          dst = buf.nextAdded;
          dstLen = buf.bufLength - buf.nextAdded;

          if ( saved != 0 )
          {
            // Here's some translated bytes left over from the last
            // buffer that we need to stick at the beginning of this
            // buffer.

            Array.Copy( safe, 0, dstArray, dst, saved );
            buf.nextAdded += saved;
            dst += saved;
            dstLen -= saved;
            saved = 0;
          }

          result = unicodeToExternal( stageArray, stage, stageLen.i, dstArray, dst, dstLen + ChannelBuffer.BUFFER_PADDING, stageRead, dstWrote, null );

          // FIXME: Not clear how this condition is dealt with.
          //
          // Fix for SF #506297, reported by Martin Forssen
          // <ruric@users.sourceforge.net>.
          //
          // The encoding chosen in the script exposing the bug writes out
          // three intro characters when TCL_ENCODING_START is set, but does
          // not consume any input as TCL_ENCODING_END is cleared. As some
          // output was generated the enclosing loop calls UtfToExternal
          // again, again with START set. Three more characters in the out
          // and still no use of input ... To break this infinite loop we
          // remove TCL_ENCODING_START from the set of flags after the first
          // call (no condition is required, the later calls remove an unset
          // flag, which is a no-op). This causes the subsequent calls to
          // UtfToExternal to consume and convert the actual input.

          encodingStart = false;

          // The following can never happen since we use unicode characters.
          //
          //if ((result != 0) && ((stageRead.i + dstWrote.i) == 0)) {
          //    // We have an incomplete UTF-8 character at the end of the
          //    // staging buffer.  It will get moved to the beginning of the
          //    // staging buffer followed by more bytes from src.
          //
          //    src -= stageLen.i;
          //    srcLen += stageLen.i;
          //    stageLen.i = 0;
          //    savedLF = 0;
          //    break;
          //}
          buf.nextAdded += dstWrote.i;
          if ( buf.nextAdded > buf.bufLength )
          {
            // When translating from unicode to external encoding, we
            // allowed the translation to produce a character that
            // crossed the end of the output buffer, so that we would
            // get a completely full buffer before flushing it.  The
            // extra bytes will be moved to the beginning of the next
            // buffer.

            saved = buf.nextAdded - buf.bufLength;
            // ATK Array.Copy(SupportClass.ToByteArray((System.Array) dstArray), dst + dstLen, SupportClass.ToByteArray(safe), 0, saved);
            Array.Copy( dstArray, dst + dstLen, safe, 0, saved );
            buf.nextAdded = buf.bufLength;
          }
          if ( checkFlush( buf, ( sawLF != 0 ) ) != 0 )
          {
            return -1;
          }

          total += dstWrote.i;
          stage += stageRead.i;
          stageLen.i -= stageRead.i;
          sawLF = 0;

          consumedSomething = true;

          // If all translated characters are written to the buffer,
          // endEncoding is set to 0 because the escape sequence may be
          // output.

          if ( ( stageLen.i + saved == 0 ) && ( result == 0 ) )
          {
            endEncoding = 0;
          }
        }
      }

      // If nothing was written and it happened because there was no progress
      // in the UTF conversion, we throw an error.

      if ( !consumedSomething && ( total == 0 ) )
      {
        //Tcl_SetErrno (EINVAL);
        return -1;
      }
      return total;
    }

    /// <summary> DoWriteChars -> doWriteChars
    /// 
    /// Takes a sequence of characters and converts them for output
    /// using the channel's current encoding, may queue the buffer for
    /// output if it gets full, and also remembers whether the current
    /// buffer is ready e.g. if it contains a newline and we are in
    /// line buffering mode. Compensates stacking, i.e. will redirect the
    /// data from the specified channel to the topmost channel in a stack.
    /// 
    /// The number of bytes written or -1 in case of error. If -1,
    /// Tcl_GetErrno will return the error code.
    /// 
    /// May buffer up output and may cause output to be produced on the
    /// channel.
    /// 
    /// </summary>
    /// <param name="src">         Chars to write.
    /// </param>
    /// <param name="srfOff">      First index in src array.
    /// </param>
    /// <param name="srfLen">      Number of chars to write.
    /// </param>

    internal int doWriteChars( char[] src, int srcOff, int srcLen )
    {
      // HACK ATK Was soll das?
      return -1;
    }

    /// <summary> Tcl_WriteObj -> writeObj
    /// 
    /// Takes the Tcl object and queues its contents for output.  If the
    /// encoding of the channel is NULL, takes the byte-array representation
    /// of the object and queues those bytes for output.  Otherwise, takes
    /// the characters in the UTF-8 (string) representation of the object
    /// and converts them for output using the channel's current encoding.
    /// May flush internal buffers to output if one becomes full or is ready
    /// for some other reason, e.g. if it contains a newline and the channel
    /// is in line buffering mode.
    /// 
    /// The number of bytes written or -1 in case of error. If -1,
    /// Tcl_GetErrno will return the error code.
    /// 
    /// May buffer up output and may cause output to be produced on the
    /// channel.
    /// 
    /// </summary>
    /// <param name="obj">         The object to write.
    /// </param>

    internal int writeObj( TclObject obj )
    {
      // Always use the topmost channel of the stack

      //char *src;
      int srcLen;

      //statePtr = ((Channel *) chan)->state;
      //chanPtr  = statePtr->topChanPtr;

      //if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
      //    return -1;
      //}

      if ( (System.Object)encoding == null )
      {
        srcLen = TclByteArray.getLength( null, obj );
        byte[] bytes = TclByteArray.getBytes( null, obj );
        return writeBytes( bytes, 0, srcLen );
      }
      else
      {
        char[] chars = obj.ToString().ToCharArray();
        return writeChars( chars, 0, chars.Length );
      }
    }
  }
}