////////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  File:   ConsoleOutput.sg
//
//  Note:   Uses /dev/conout to display console output.
//

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

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

    using System.Runtime.InteropServices;

    public sealed class ConsoleOutput : ITracked
    {
        private static TContainer<ConsoleOutput> consoleContainer;

        private struct PipeData : ITracked {
            public UnicodePipeContract.Imp channel;
            public void Dispose()
            {
                delete channel;
            }
            void ITracked.Acquire() {}
            void ITracked.Release() {}
            public void Expose() {}
            public void UnExpose() {}

            public UnicodePipeContract.Imp:READY Swap([Claims] UnicodePipeContract.Imp:READY newPipe) {
                expose (this) {
                    UnicodePipeContract.Imp result = this.channel;
                    this.channel = newPipe;
                    return result;
                }
            }
        }

        /*
        private struct DeviceData : ITracked {
            public ConsoleDeviceContract.Imp:Ready channel;
            public void Dispose()
            {
                delete channel;
            }
            void ITracked.Acquire() {}
            void ITracked.Release() {}
            public void Expose() {}
            public void UnExpose() {}
        }
        */

        private char[]! in ExHeap side;
        private PipeData pipe;
        /*
        private DeviceData device;
        */
        private ConsoleOutput([Claims] UnicodePipeContract.Imp? pipe)
        {
            this.side = new[ExHeap] char [280];
            this.pipe.channel = pipe;
        }

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

            Endpoint* in ExHeap pipeep = Process.GetStartupEndpoint(1);
            if (pipeep != null) {
                con = pipeep as UnicodePipeContract.Imp;
                if (con == null) {
                    Process.RetStartupEndpoint(1,pipeep);
                    return null;
                }
                return con;
            }
            return null;
        }

        public static void Initialize()
        {
            /*
            ConsoleDeviceContract.Imp imp = null;

            imp = OpenConsole("/dev/video-text");
            if (imp == null) {
                imp = OpenConsole("/dev/conout");
                if (imp == null) {
                    DebugStub.Print("Couldn't open console.\n");
                    return;
                }
            }
            */
            UnicodePipeContract.Imp pipe = GetPipe();
            ConsoleOutput co = new ConsoleOutput(pipe);
            consoleContainer = new TContainer<ConsoleOutput>(co);
        }

        public void Dispose()
        {
            this.pipe.Dispose();
            // this.device.Dispose();
            delete this.side;
        }

        void ITracked.Acquire() {
            //Tracing.Log(Tracing.Debug,"ConsoleOutput.Acquire");
        }
        void ITracked.Release() {
            //Tracing.Log(Tracing.Debug,"ConsoleOutput.Release");
        }
        void ITracked.Expose() {
            //Tracing.Log(Tracing.Debug,"ConsoleOutput.Expose");
        }
        void ITracked.UnExpose() {
            //Tracing.Log(Tracing.Debug,"ConsoleOutput.UnExpose");
        }

        public static void Finalize()
        {
            TContainer<ConsoleOutput> chandle = consoleContainer;
            consoleContainer = null;

            if (chandle == null) return;

            ConsoleOutput co = chandle.Acquire();
            if (co != null) co.Dispose();
        }

        /*
        private static ConsoleDeviceContract.Imp
        OpenConsoleInternal(DirectoryServiceContract.Imp! nsImp,
                            [Claims] char[]! in ExHeap    deviceName)
        {
            ConsoleDeviceContract.Exp! exp;
            ConsoleDeviceContract.Imp! imp;
            ConsoleDeviceContract.NewChannel(out imp, out exp);

            nsImp.SendBind(deviceName, exp);
            switch receive
            {
                case nsImp.AckBind():
                    return imp;
                    break;
                case nsImp.NakBind(rejectImp, error):
                    delete rejectImp;
                    delete imp;
                    break;
                case nsImp.ChannelClosed():
                    throw new Exception("Channel closed during Console bind.");
                    delete imp;
                    break;
                case nsImp.NakBindReparse(path, rest, linked, backExp):
                    assert linked == true;
                    assert rest   == null;
                    delete backExp;
                    delete imp;

                    return OpenConsoleInternal(nsImp, path);
                    break;
            }
            return null;
        }

        private static ConsoleDeviceContract.Imp OpenConsole(string! devName)
        {
            DirectoryServiceContract.Imp ns = DirectoryService.NewClientEndpoint();
            ConsoleDeviceContract.Imp imp =
                OpenConsoleInternal(ns, Bitter.FromString2(devName));
            delete ns;

            if (imp != null) {
                switch receive
                {
                    case imp.Success():
                        break;
                    case imp.ContractNotSupported():
                        throw new Exception("ConsoleOutput: ContractNotSupported");
                        break;
                    case imp.ChannelClosed():
                        throw new Exception("ConsoleOutput: ChannelClosed");
                        break;
                }
            }
            return imp;
        }

        public static void Clear()
        {
            if (consoleContainer == null) return;

            ConsoleOutput co = consoleContainer.Acquire();

            expose (co) {
                ConsoleDeviceContract.Imp ep = co.device.channel;
                if (ep != null)
                {
                    ep.SendClear();
                    switch receive
                    {
                    case ep.AckClear():
                        break;
                    case ep.NakClear():
                        break;
                    case ep.ChannelClosed():
                        delete ep;
                        co.device.channel = null;
                        break;
                    }
                }
            }
            consoleContainer.Release(co);
        }

        public static void CursorFlash()
        {
            if (consoleContainer == null) return;

            ConsoleOutput co = consoleContainer.Acquire();

            expose (co) {
                ConsoleDeviceContract.Imp ep = co.device.channel;
                if (ep != null) 
                {
                    ep.SendCursorFlash();
                    switch receive
                    {
                    case ep.AckCursorFlash():
                        break;
                    case ep.NakCursorFlash():
                        break;
                    case ep.ChannelClosed():
                        delete ep;
                        co.device.channel = null;
                        break;
                    }
                }
            }
            consoleContainer.Release(co);
        }

        public static void CursorHide()
        {
            if (consoleContainer == null) return;

            ConsoleOutput co = consoleContainer.Acquire();

            expose (co) {
                ConsoleDeviceContract.Imp ep = co.device.channel;
                if (ep != null) {
                    ep.SendCursorHide();
                    switch receive {
                    case ep.AckCursorHide():
                        break;
                    case ep.NakCursorHide():
                        break;
                    case ep.ChannelClosed():
                        delete ep;
                        co.device.channel = null;
                        break;
                    }
                }
            }
            consoleContainer.Release(co);
        }

        public static void CursorShow()
        {
            if (consoleContainer == null) return;

            ConsoleOutput co = consoleContainer.Acquire();

            expose (co) {
                ConsoleDeviceContract.Imp ep = co.device.channel;
                if (ep != null) {
                    ep.SendCursorShow();
                    switch receive {
                    case ep.AckCursorShow():
                        break;
                    case ep.NakCursorShow():
                        break;
                    case ep.ChannelClosed():
                        delete ep;
                        co.device.channel = null;
                        break;
                    }
                }
            }
            consoleContainer.Release(co);
        }
        */

        public static char[]! in ExHeap Write([Claims] char[]! in ExHeap buffer,
                                              int index, int count)
        {
            if (consoleContainer == null) return buffer;
            ConsoleOutput co = consoleContainer.Acquire();
            try {
                expose (co) {
                    if (co.pipe.channel != null) {
                        return Write(buffer, index, count, ref co.pipe);
                    }
                    else {
                        return buffer;
                    }
                }
            }
            finally {
                consoleContainer.Release(co);
            }
        }

        /*
        private static char[]! in ExHeap Write([Claims] char[]! in ExHeap buffer,
                                               int index, int count,
                                               ref DeviceData device)
        {
            expose (device) {
                ConsoleDeviceContract.Imp channel = device.channel;
                if (channel != null)
                {
                    channel.SendWrite(buffer, index, count);
                    switch receive {
                    case channel.AckWrite(localside):
                        return localside;

                    case channel.NakWrite(localside):
                        return localside;

                    case channel.ChannelClosed():
                        delete channel;
                        device.channel = null;
                        return new[ExHeap] char[0];
                    }                      
                }
                else {
                    return buffer;
                }
            }
        }
        */

        private static char[]! in ExHeap Write([Claims] char[]! in ExHeap buffer,
                                               int index, int count,
                                               ref PipeData pipe)
        {
            expose (pipe) {
                UnicodePipeContract.Imp channel = pipe.channel;
                if (channel != null) {
                    //                    char[]! in ExHeap buffer=Bitter.FromString2(value);
                    channel.SendWrite(buffer, index, count);
                    switch receive { 
                    case channel.AckWrite(i_buffer):
                        return i_buffer;
                    
                    case channel.ChannelClosed():
                        delete channel;
                        pipe.channel = null;
                        return new[ExHeap] char[0];

                    case unsatisfiable:
                        DebugStub.Break();
                        throw new Exception("Pipe unsatisfiable "); 
                    }
                }
                else {
                    return buffer;
                }
            }
        }

        public static void Write(char[]! buffer, int index, int count)
        {
            if (consoleContainer == null) return;

            ConsoleOutput co = consoleContainer.Acquire();

            expose (co) {
                char[] in ExHeap side = co.side;

                if (side.Length < count) {
                    delete side;
                    co.side = side = new[ExHeap] char [count];
                }

                for (int i = 0; i < count; i++) {
                    side[i] = buffer[index + i];
                }

                if (co.pipe.channel != null) {
                    co.side = Write(side, index, count, ref co.pipe);
                }
                /*
                else {
                    co.side = Write(side, index, count, ref co.device);
                }
                */
            }
            consoleContainer.Release(co);
        }

        public static void Write(String! value)
        {
            if (consoleContainer == null) return;

            ConsoleOutput co = consoleContainer.Acquire();

            expose (co) {

                char[] in ExHeap side = co.side;
                if (side.Length < value.Length) {
                    delete side;
                    co.side = side = new[ExHeap] char [value.Length];
                }

                for (int i = 0; i < value.Length; i++) {
                    side[i] = value[i];
                }

                if (co.pipe.channel != null) {
                    co.side = Write(side, 0, value.Length, ref co.pipe);
                }
                /*
                else {
                    co.side = Write(side, 0, value.Length, ref co.device);
                }
                */
            }
            consoleContainer.Release(co);
            return;
        }

        public static UnicodePipeContract.Imp:READY Swap([Claims] UnicodePipeContract.Imp:READY newOutput) {
            if (consoleContainer == null) {
                delete newOutput;
                return null;
            }

            ConsoleOutput co = consoleContainer.Acquire();

            UnicodePipeContract.Imp result;
            expose(co) {
                result = co.pipe.Swap(newOutput);
            }
            consoleContainer.Release(co);
            return result;
        }

    }
}