////////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  Note:   Simple Singularity test program.
//

using System;
using System.Threading;
using Microsoft.Singularity.Channels;

using Microsoft.Contracts;
using Microsoft.SingSharp.Reflection;
using Microsoft.Singularity.Applications;
using Microsoft.Singularity.Io;
using Microsoft.Singularity.Configuration;
[assembly: Transform(typeof(ApplicationResourceTransform))]

namespace Microsoft.Singularity.Applications
{
    [ConsoleCategory(DefaultAction=true)]
    internal class Parameters {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        [BoolParameter( "set", Default=false, HelpMessage="Run set test.")]
        internal bool doSetTest;

        reflective internal Parameters();

        internal int AppMain() {
            return Select.AppMain(this);
        }
    }
    
    public class Select
    {
        private contract SelectTest {
            in message A();
            in message B();
            in message C();
            out message Ack();

            state Start: one {
                A? -> Ack! -> Start;
                B? -> Ack! -> Start;
                C? -> Ack! -> Start;
            }
        }

        private static TRef<SelectTest.Imp:Start>[] impEndpoints;


        public static void SelectThread()
        {
            SelectTest.Imp[] channel = new SelectTest.Imp [3];
            for (int i = 0; i < 3; i++) {
                channel[i] = impEndpoints[i].Acquire();
            }

            channel[2].SendA();
            channel[2].RecvAck();

            channel[2].SendA();
            channel[2].RecvAck();

            channel[2].SendA();
            channel[2].RecvAck();

            channel[1].SendC();
            channel[0].SendB();
            channel[1].RecvAck();
            channel[0].RecvAck();

            channel[0].SendA();
            channel[1].SendC();
            channel[0].RecvAck();
            channel[1].RecvAck();

            channel[1].SendC();
            channel[0].SendA();

            channel[0].RecvAck();
            channel[1].RecvAck();

            channel[0].SendB();
            channel[1].SendA();
            channel[2].SendC();

            delete channel[0];
            delete channel[1];
            delete channel[2];
        }

        //[ShellCommand("selectb", "Run select test")]
        public static int DoSelect()
        {
            SelectTest.Exp[] expEndpoints = new SelectTest.Exp [3];
            impEndpoints = new TRef<SelectTest.Imp:Start> [3];

            for (int i = 0; i < 3; i++) {
                SelectTest.Imp! imp;
                SelectTest.Exp! exp;
                SelectTest.NewChannel(out imp, out exp);
                expEndpoints[i] = exp;
                impEndpoints[i] = new TRef<SelectTest.Imp:Start>(imp);
            }

            Thread t1 = new Thread(new ThreadStart(SelectThread));
            t1.Start();

            SelectTest.Exp a = expEndpoints[0];
            SelectTest.Exp b = expEndpoints[1];
            SelectTest.Exp c = expEndpoints[2];

            bool failed = false;
            ActuallySelect(a, b, c, 0, ref failed);
            ActuallySelect(a, b, c, 0, ref failed);
            ActuallySelect(a, b, c, 0, ref failed);
            ActuallySelect(a, b, c, 1, ref failed);
            ActuallySelect(a, b, c, 2, ref failed);
            ActuallySelect(a, b, c, 2, ref failed);
            ActuallySelect(a, b, c, -1, ref failed);

            if (failed) {
                Console.WriteLine("[1] Done (FAILED).");
                return 1;
            }
            else {
                Console.WriteLine("[1] Done (Success).");
                return 0;
            }
        }

        private static void ActuallySelect(SelectTest.Exp a,
                                           SelectTest.Exp b,
                                           SelectTest.Exp c,
                                           int expect,
                                           ref bool failed)
        {
            int got;
            switch receive {
                case c.RecvA():
                    c.SendAck();
                    got = 0;
                    break;

                case a.RecvB() && b.RecvC():
                    a.SendAck();
                    b.SendAck();
                    got = 1;
                    break;

                case a.RecvA() && b.RecvC():
                    a.SendAck();
                    b.SendAck();
                    got = 2;
                    break;

                case unsatisfiable:
                    got = -1;
                    break;
            }

            Console.WriteLine("[1] expected {0}, got {1}", expect, got);
            if (expect != got) {
                failed = true;
            }
        }

        private static void ActuallySelect(ESet<SelectTest.Exp:Start> eset,
                                           int expect,
                                           ref bool failed)
        {
            int got;
            switch receive {
                case a.RecvA() in eset:
                    got = 0;
                    a.SendAck();
                    eset.Add(a);
                    break;

                case b.RecvB() in eset:
                    got = 1;
                    b.SendAck();
                    eset.Add(b);
                    break;

                case c.RecvC() in eset:
                    got = 2;
                    c.SendAck();
                    eset.Add(c);
                    break;

                case unsatisfiable:
                    got = -1;
                    break;
            }

            Console.WriteLine("[1] expected {0}, got {1}", expect, got);
            if (expect != got) {
                failed = true;
            }
        }

        public static int DoSelectSet()
        {
            SelectTest.Exp[] expEndpoints = new SelectTest.Exp [3];
            impEndpoints = new TRef<SelectTest.Imp:Start> [3];

            for (int i = 0; i < 3; i++) {
                SelectTest.Imp! imp;
                SelectTest.Exp! exp;
                SelectTest.NewChannel(out imp, out exp);
                expEndpoints[i] = exp;
                impEndpoints[i] = new TRef<SelectTest.Imp:Start>(imp);
            }

            Thread t1 = new Thread(new ThreadStart(SelectThread));
            t1.Start();

            SelectTest.Exp a = expEndpoints[0];
            SelectTest.Exp b = expEndpoints[1];
            SelectTest.Exp c = expEndpoints[2];

            ESet<SelectTest.Exp:Start> eset = new ESet<SelectTest.Exp:Start>();
            eset.Add(a);
            eset.Add(b);
            eset.Add(c);

            bool failed = false;
            ActuallySelect(eset, 0, ref failed);
            ActuallySelect(eset, 0, ref failed);
            ActuallySelect(eset, 0, ref failed);
            ActuallySelect(eset, 1, ref failed);
            ActuallySelect(eset, 2, ref failed);
            ActuallySelect(eset, 0, ref failed);
            ActuallySelect(eset, 2, ref failed);
            ActuallySelect(eset, 0, ref failed);
            ActuallySelect(eset, 2, ref failed);
            ActuallySelect(eset, 0, ref failed);
            ActuallySelect(eset, 1, ref failed);
            ActuallySelect(eset, 2, ref failed);
            ActuallySelect(eset, -1, ref failed);

            if (failed) {
                Console.WriteLine("[1] Done (FAILED).");
                return 1;
            }
            else {
                Console.WriteLine("[1] Done (Success).");
                return 0;
            }
        }

        //
        ////[ShellCommand("select", "Run select test")]
        //public static int DoSelect()
        //{
        //  SelectTest.Exp[] expEndpoints = new SelectTest.Exp [3];
        //  impEndpoints = new TRef<SelectTest.Imp:Start> [3];
//
        //  for (int i = 0; i < 3; i++) {
        //      SelectTest.Imp! imp;
        //      SelectTest.Exp! exp;
        //      SelectTest.NewChannel(out imp, out exp);
        //      expEndpoints[i] = exp;
        //      impEndpoints[i] = new TRef<SelectTest.Imp:Start>(imp);
        //  }
//
        //  Thread t1 = new Thread(new ThreadStart(SelectThread));
        //  t1.Start();
//
        //  int[][] patterns = new int[3][];
        //  patterns[0] = new int [] { 0, 0, SelectTest.Tags.A };
        //  patterns[1] = new int [] { SelectTest.Tags.B, SelectTest.Tags.C, 0 };
        //  patterns[2] = new int [] { SelectTest.Tags.A, SelectTest.Tags.C, 0 };
//
        //  ISelectable[] selects = new ISelectable[3];
        //  for (int i = 0; i < 3; i++) {
        //      selects[i] = expEndpoints[i];
        //  }
//
        //  object setMatch;
        //  int i1 = Endpoint.Select(patterns, selects, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 0.)", i1);
//
        //  expEndpoints[2].RecvA();
        //  expEndpoints[2].SendAck();
//
        //  int i2 = Endpoint.Select(patterns, selects, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 0.)", i2);
//
        //  expEndpoints[2].RecvA();
        //  expEndpoints[2].SendAck();
//
        //  int i3 = Endpoint.Select(patterns, selects, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 0.)", i3);
//
        //  expEndpoints[2].RecvA();
        //  expEndpoints[2].SendAck();
//
        //  int i4 = Endpoint.Select(patterns, selects, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 1.)", i4);
//
        //  expEndpoints[0].RecvB();
        //  expEndpoints[1].RecvC();
        //  expEndpoints[0].SendAck();
        //  expEndpoints[1].SendAck();
//
        //  int i5 = Endpoint.Select(patterns, selects, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 2.)", i5);
//
        //  expEndpoints[0].RecvA();
        //  expEndpoints[1].RecvC();
        //  expEndpoints[0].SendAck();
        //  expEndpoints[1].SendAck();
//
        //  int i6 = Endpoint.Select(patterns, selects, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 2.)", i6);
//
        //  expEndpoints[0].RecvA();
        //  expEndpoints[1].RecvC();
        //  expEndpoints[0].SendAck();
        //  expEndpoints[1].SendAck();
//
        //  int i7 = Endpoint.Select(patterns, selects, out setMatch);
        //  Console.WriteLine("[1] Got {0}! (Expected -1.)", i7);
//
        //  Console.WriteLine("[1] Done.");
        //  return 0;
        //}
//
//
        ////[ShellCommand("selectset", "Run select set test")]
        //public static int DoSelectSet()
        //{
        //  SelectTest.Exp[] expEndpoints = new SelectTest.Exp [3];
        //  impEndpoints = new TRef<SelectTest.Imp:Start> [3];
//
        //  for (int i = 0; i < 3; i++) {
        //      SelectTest.Imp! imp;
        //      SelectTest.Exp! exp;
        //      SelectTest.NewChannel(out imp, out exp);
        //      expEndpoints[i] = exp;
        //      impEndpoints[i] = new TRef<SelectTest.Imp:Start>(imp);
        //  }
//
        //  Thread t1 = new Thread(new ThreadStart(SelectThread));
        //  t1.Start();
//
        //  int[][] patterns = new int[3][];
        //  patterns[0] = new int [] { SelectTest.Tags.A };
        //  patterns[1] = new int [] { SelectTest.Tags.B };
        //  patterns[2] = new int [] { SelectTest.Tags.C };
//
        //  ESet<SelectTest.Exp:Start> eset = new ESet<SelectTest.Exp:Start>();
        //  eset.Add(expEndpoints[0]);
        //  eset.Add(expEndpoints[1]);
        //  eset.Add(expEndpoints[2]);
//
        //  ISelectable[] selectEPs = new ISelectable[1]{eset};
//
        //  object setMatch;
        //  int i1 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 0.)", i1);
//
        //  SetRecvA(setMatch, eset);
//
        //  int i2 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 0.)", i2);
//
        //  SetRecvA(setMatch, eset);
//
        //  int i3 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 0.)", i3);
//
        //  SetRecvA(setMatch, eset);
//
        //  int i4 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 1.)", i4);
//
        //  SetRecvB(setMatch, eset);
//
        //  int i5 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 2.)", i5);
//
        //  SetRecvC(setMatch, eset);
//
        //  int i6 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}!  (Expected 0.)", i6);
//
        //  SetRecvA(setMatch, eset);
//
        //  int i7 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}! (Expected 2.)", i7);
//
        //  SetRecvC(setMatch, eset);
//
        //  int i8 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}! (Expected 0.)", i8);
//
        //  SetRecvA(setMatch, eset);
//
        //  int i9 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}! (Expected 2.)", i9);
//
        //  SetRecvC(setMatch, eset);
//
        //  int i10 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}! (Expected 0.)", i10);
//
        //  SetRecvA(setMatch, eset);
//
        //  int i11 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}! (Expected 1.)", i11);
//
        //  SetRecvB(setMatch, eset);
//
        //  int i12 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}! (Expected 2.)", i12);
//
        //  SetRecvC(setMatch, eset);
//
        //  int i13 = Endpoint.Select(patterns, selectEPs, out setMatch);
        //  Console.WriteLine("[1] Got {0}! (Expected -1.)", i13);
//
        //  Console.WriteLine("[1] Done.");
        //  return 0;
        //}
//
        //private static void SetRecvA(object match, ESet<SelectTest.Exp:Start> eset) {
        //  SelectTest.Exp exp = eset.Extract(match);
        //  exp.RecvA();
        //  exp.SendAck();
        //  eset.Add(exp);
        //}
//
        //private static void SetRecvB(object match, ESet<SelectTest.Exp:Start> eset) {
        //  SelectTest.Exp exp = eset.Extract(match);
        //  exp.RecvB();
        //  exp.SendAck();
        //  eset.Add(exp);
        //}
//
        //private static void SetRecvC(object match, ESet<SelectTest.Exp:Start> eset) {
        //  SelectTest.Exp exp = eset.Extract(match);
        //  exp.RecvC();
        //  exp.SendAck();
        //  eset.Add(exp);
        //}
        //

        internal static int AppMain(Parameters! config)
        {
            const int ARGS_START = 1;

            if (config.doSetTest) return DoSelectSet();
            return DoSelect();
        }
    }
}