//////////////////////////////////////////////////////////////////////////////////
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  File:   ConsoleInput.sg
//
//  Note:   Read a line or a char of the Console
//

using DirectoryService.Utils;
using System.GC;
using System.Runtime.Remoting;
using System.Threading;
using System.Collections;
using System.Diagnostics;
using Microsoft.Singularity.V1.Services;


namespace Microsoft.Singularity.Io
{
    using Microsoft.SingSharp;
    using Microsoft.Singularity;
    using Microsoft.Singularity.V1.Services;
    using Microsoft.Singularity.V1.Threads;
    using Microsoft.Singularity.Channels;
    using Microsoft.Singularity.Directory;

    using System;
    using System.Text;
    using System.Globalization;
    using System.Runtime.CompilerServices;

    using Microsoft.Singularity.Extending;
    using Microsoft.Singularity.Runtime;
    using Microsoft.Singularity.Io;
    using System.Runtime.InteropServices;



    public sealed class ConsoleInput // : ITracked, ISelectable   
    {
        private static TContainer<PipeLookAhead> consoleContainer;
        // protected by TContainer lock.
        private static char[]! readLineBuffer = new char[16];

        //
//
        //private char[]! in ExHeap side;
        //private UnicodePipeContract.Exp conn;
        //private int charCount;
        //private int charPos;
//
        //private ConsoleInput([Claims] UnicodePipeContract.Exp? pipe)
        //{
        //  this.side = new[ExHeap] char [280];
        //  this.charCount = 0;
        //  this.charPos = 0;
        //  this.conn = pipe;
//
        //  base();
        //}
        //

        private ConsoleInput() {}

        private static UnicodePipeContract.Exp? GetPipe()
        {
            UnicodePipeContract.Exp con = null;

            Endpoint * in ExHeap pipeep = Process.GetStartupEndpoint(0);
            if (pipeep != null) {
                con = pipeep as UnicodePipeContract.Exp;
                if (con == null) {
                    // This is benign.  Processes that use manifests to declare their endpoints
                    // will probably not have a UnicodePipeContract.Exp at index 0.  In fact,
                    // if they declare such, they will encounter problems because of the conflict
                    // with this method (and its caller).  Need to determine the right way to do
                    // this.
                    Process.RetStartupEndpoint(0,pipeep);
                    return null;
                }
                else {
                    //DebugStub.WriteLine("ConsoleInput: connected to pipe.");
                    return con;
                }
            }
            return null;
        }


        public static void Initialize()
        {
            UnicodePipeContract.Exp pipe = GetPipe();
            PipeLookAhead bufferedPipe = new PipeLookAhead(pipe, 100);
            ConsoleInput.consoleContainer = new TContainer<PipeLookAhead>(bufferedPipe);
        }

        //
        //public void Dispose()
        //{
        //  delete this.side;
        //  delete this.conn;
        //}
//
        //void ITracked.Acquire() {
        //  Tracing.Log(Tracing.Debug,"ConsoleInput.Acquire");
        //}
        //void ITracked.Release() {
        //  Tracing.Log(Tracing.Debug,"ConsoleInput.Release");
        //}
        //void ITracked.Expose() {
        //  Tracing.Log(Tracing.Debug,"ConsoleInput.Expose");
        //}
        //void ITracked.UnExpose() {
        //  Tracing.Log(Tracing.Debug,"ConsoleInput.UnExpose");
        //}
        //

        public static void Finalize()
        {
            //            TContainer<ConsoleInput> chandle = consoleContainer;
            TContainer<PipeLookAhead> chandle = consoleContainer;
            consoleContainer = null;

            if (chandle == null) return;

            PipeLookAhead co = chandle.Acquire();
            co.Dispose();
        }

        //
        //private int InternalReadChar()
        //{
        //  expose (this) {
        //      if (this.conn != null) {
        //          if (this.charCount == 0) {
        //              UnicodePipeContract.Exp pipe = this.conn;
//
        //          tryAgain:
        //              switch receive {
        //                  case pipe.Write(buffer,a,b):
        //                      if (b == 0) {
        //                          pipe.SendAckWrite(buffer);
        //                          goto tryAgain;
        //                      }
        //                      if (b == 1) {
        //                          int theChar = (int) buffer[a];
        //                          pipe.SendAckWrite(buffer);
        //                          return theChar;
        //                      }
        //                      else {
        //                          // switch our buffer with theirs
        //                          pipe.SendAckWrite(this.side);
        //                          this.side = buffer;
        //                          this.charPos = a+1;
        //                          this.charCount = b-1;
        //                          return (int)buffer[a];
        //                      }
//
        //                  case pipe.ChannelClosed():
        //                      return -1;
        //              }
        //          }
        //          else {
        //              // there are more chars in the buffer
        //              int theChar = this.side[this.charPos++];
        //              this.charCount--;
        //              return theChar;
        //          }
        //      }
        //  } //expose
        //  return -1;
        //}
        //

        public static void Close()
        {
        }

        public static int ReadChar()
        {
            if (consoleContainer == null) return -1;
            PipeLookAhead co = consoleContainer.Acquire();
            int key = co.ReadChar();
            if (key == -1) {
                co.Dispose();
                consoleContainer = null;
                return key;
            }
            consoleContainer.Release(co);
            return key;
        } //ReadChar

        ////////////////////////////////////////////////////////
        //
        public static string ReadLine()
        {
            if (consoleContainer == null) return null;
            PipeLookAhead bufferedPipe = consoleContainer.Acquire();

            int pos = 0;
            int key;

            do {
                key = bufferedPipe.ReadChar();
                if (key == -1) {
                    bufferedPipe.Dispose();
                    consoleContainer = null;
                    return null;
                }
                if (key == '\r') {
                    // DebugStub.WriteLine("key {0}", key);
                    continue;
                }
                if (key == '\n') {
                    // DebugStub.WriteLine("key {0}", key);
                    break;
                }
                if (pos + 1 >= readLineBuffer.Length) {
                    char[] temp = new char[readLineBuffer.Length *2];
                    Array.Copy(readLineBuffer,temp,readLineBuffer.Length);
                    readLineBuffer = temp;
                }
                readLineBuffer[pos++] = (char) key;
                if (key > 31 && key < 126) {
                    // DebugStub.WriteLine("key {0}", key);
                }
            } while (key != -1);

            string s = new string(readLineBuffer,0,pos);
            //DebugStub.WriteLine("in: count={0}, s=({1})",__arglist(pos, s));

            consoleContainer.Release(bufferedPipe);
            return s;
        } //ReadLine

        //
        //internal enum ReceiveTag {
        //  Any = 1,
        //  GetChar = 2,
        //}
//
        //[Selectable((int)ReceiveTag.GetChar)]
        //public void RecvGetChar(out int key) {
        //  key = this.InternalReadChar();
        //}
//
        ///// <summary>
        ///// Tests if the message at the head of the queue matches the given tag. If so,
        ///// returns true.
        /////
        ///// If no match is possible in the future given the current message, possible must
        ///// be set to false.
        ///// Implementations are disallowed from setting possible to true
        ///// so that the context can chain them.
        /////
        ///// If the underlying object is an endpoint set, it also returns an object that
        ///// serves to extract the endpoint having the match from the set later.
        /////
        ///// Again, implementations are disallowed from setting match setMatch to null
        ///// so that the context can chain the calls.
        /////
        ///// </summary>
        //bool ISelectable.HeadMatches(int tag, ref bool possible, ref object setMatch) {
        //  // Only handle pipe case
        //  expose (this) {
        //      if (this.conn != null) {
        //          if (this.charCount == 0) {
        //              UnicodePipeContract.Exp pipe = this.conn;
//
        //              // negative tag is channel closed
        //              int pipeTag = (tag < 0)?tag : UnicodePipeContract.Tags.Write;
//
        //              return pipe.HeadMatches(pipeTag, ref possible, ref setMatch);
        //          }
        //          else {
        //              // there are more chars in the buffer
        //              if (tag < 0) {
        //                  // not closed
        //                  possible = false;
        //                  return false;
        //              }
        //              return true;
        //          }
        //      }
        //      else {
        //          // no pipe
        //          possible = false;
        //          return false;
        //      }
        //  } //expose
        //}
//
        //SyncHandle ISelectable.GetWaitHandle() {
        //  expose (this) {
        //      assert(this.conn != null);
        //      return this.conn.GetWaitHandle();
        //  }
        //}
//
        //
        public static PipeLookAhead! AcquireInput() {
            assert consoleContainer != null;

            PipeLookAhead bufferedPipe = consoleContainer.Acquire();
            return bufferedPipe;
        }

        public static void ReleaseInput([Claims] PipeLookAhead! bufferedPipe) {
            assert consoleContainer != null;

            consoleContainer.Release(bufferedPipe);
        }

    } //ConsoleInput
}//namespace