<?xml version="1.0" encoding="utf-8"?>
<xsharper xmlns="http://www.xsharper.com/schemas/1.0">



        <reference name="System.Management.Automation" withTypes="1" />
       
    <?ht using System.Management.Automation;
       using System.Management.Automation.Host;
       using System.Management.Automation.Runspaces;
       using System.Collections.ObjectModel;

       [XS.XsType("powershell")]
       public class PowerShell : XSharper.Core.StaticValueFromFileBase
       {
           /// Where to output the subroutine value.
           public string OutTo { get; set; }

           /// Input collection
           public object Input { get; set; }

           /// Call isolation
           public XS.CallIsolation Isolation { get; set; }
                     
           public PowerShell()
           {
               Isolation = XS.CallIsolation.High;
           }

           public override object Execute()
           {
               object x=base.Execute();
               if (x != null)
                   return x;

               var s = Context.Transform(Input, Transform);
                   if (s != null && !(s is System.Collections.IEnumerable))
                       s = new[] {s};
                   
               object ret = execInternal(GetTransformedValueStr(), s, (Isolation == XS.CallIsolation.High)?null:Context);
               Context.OutTo(OutTo, ret);
               return null;
           }
           static public object Exec(string script)
           {
               return execInternal(script, null, null);
           }
           static public object Exec(string script, object input)
           {
               return execInternal(script, input, null);
           }

           static private object execInternal(string script, object input, IEnumerable<XS.Var> vars)
           {
           
               MyHost host = new MyHost(XS.ScriptContextScope.Current);
               using (var runspace = RunspaceFactory.CreateRunspace(host))
               {
                   runspace.Open();
                   if (vars!=null)
                       foreach (XS.Var v in vars)
                           runspace.SessionStateProxy.SetVariable(v.Name, v.Value);

                   var ie = input as System.Collections.IEnumerable;
                   using (Pipeline pipeline = runspace.CreatePipeline())
                   {
                       pipeline.Commands.AddScript(script);
                       return (ie == null) ? pipeline.Invoke() : pipeline.Invoke(ie);
                   }
               }
           }

           #region -- internal --
           class MyHost : PSHost
           {
               public MyHost(XS.ScriptContext c) { _c = c; _ui = new UserInterface(c); }

               public override void SetShouldExit(int exitCode) { throw new XS.ScriptTerminateException(exitCode); }
               public override void EnterNestedPrompt() { throw new NotImplementedException(); }
               public override void ExitNestedPrompt() { throw new NotImplementedException(); }
               public override void NotifyBeginApplication() { }
               public override void NotifyEndApplication() { }
               public override string Name { get { return (_c.Script == null || string.IsNullOrEmpty(_c.Script.Id)) ? "XSharper" : _c.Script.Id; } }
               public override Version Version
               {
                   get
                   {
                       if (_c.Script != null && _c.Script.VersionInfo != null)
                       {
                           var s = _c.TransformStr(_c.Script.VersionInfo.Version, _c.Script.VersionInfo.Transform);
                           if (!string.IsNullOrEmpty(s))
                               return new Version(s);
                       }
                       return new Version(0, 0, 0, 0);

                   }
               }
               public override Guid InstanceId { get { return _myId; } }
               public override PSHostUserInterface UI { get { return _ui; } }
               public override CultureInfo CurrentCulture { get { return _originalCultureInfo; } }
               public override CultureInfo CurrentUICulture { get { return _originalUICultureInfo; } }

               private readonly XS.ScriptContext _c;
               private readonly CultureInfo _originalCultureInfo = System.Threading.Thread.CurrentThread.CurrentCulture;
               private readonly CultureInfo _originalUICultureInfo = System.Threading.Thread.CurrentThread.CurrentUICulture;
               private readonly Guid _myId = Guid.NewGuid();
               private readonly PSHostUserInterface _ui;
           }

           class RawUi : PSHostRawUserInterface
           {
               private XS.ScriptContext _c;
               public RawUi(XS.ScriptContext scriptContext) { _c = scriptContext; }
               public override KeyInfo ReadKey(ReadKeyOptions options)
               {
                   if (!Console.KeyAvailable)
                   {
                       _c.CheckAbort();
                       System.Threading.Thread.Sleep(10);
                   }
                   ConsoleKeyInfo k = Console.ReadKey((options & ReadKeyOptions.NoEcho) == ReadKeyOptions.NoEcho);
                   ControlKeyStates ks = 0;

                   if ((k.Modifiers & ConsoleModifiers.Alt) == ConsoleModifiers.Alt)
                       ks |= ControlKeyStates.LeftAltPressed;
                   if ((k.Modifiers & ConsoleModifiers.Control) == ConsoleModifiers.Control)
                       ks |= ControlKeyStates.LeftAltPressed;
                   if ((k.Modifiers & ConsoleModifiers.Shift) == ConsoleModifiers.Shift)
                       ks |= ControlKeyStates.ShiftPressed;
                   if (Console.CapsLock)
                       ks |= ControlKeyStates.CapsLockOn;
                   return new KeyInfo((int)k.Key, k.KeyChar, ks, false);
               }

               public override void FlushInputBuffer() { }
               public override void SetBufferContents(Coordinates origin, BufferCell[,] contents) { throw new NotImplementedException(); }
               public override void SetBufferContents(Rectangle rectangle, BufferCell fill) { throw new NotImplementedException(); }
               public override BufferCell[,] GetBufferContents(Rectangle rectangle) { throw new NotImplementedException(); }
               public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { throw new NotImplementedException(); }
               public override ConsoleColor ForegroundColor { get { return Console.ForegroundColor; } set { } }
               public override ConsoleColor BackgroundColor { get { return Console.BackgroundColor; } set { } }
               public override Coordinates CursorPosition { get { return new Coordinates(Console.CursorLeft, Console.CursorTop); } set { } }
               public override Coordinates WindowPosition { get { return new Coordinates(Console.WindowLeft, Console.WindowTop); } set { } }
               public override int CursorSize { get { return Console.CursorSize; } set { Console.CursorSize = value; } }
               public override Size BufferSize
               {
                   get
                   {
                       return new Size(XS.Utils.HasRealConsole ? Console.BufferWidth : 120, XS.Utils.HasRealConsole ? Console.BufferHeight : 60);
                   }
                   set
                   {
                       Console.BufferHeight = value.Height;
                       Console.BufferWidth = value.Width;
                   }
               }
               public override Size WindowSize
               {
                   get { return new Size(Console.WindowWidth, Console.WindowHeight); }
                   set
                   {
                       Console.WindowHeight = value.Height;
                       Console.WindowWidth = value.Width;
                   }
               }
               public override Size MaxWindowSize { get { return new Size(Console.LargestWindowWidth, Console.LargestWindowHeight); } }
               public override Size MaxPhysicalWindowSize { get { return MaxWindowSize; } }
               public override bool KeyAvailable { get { return Console.KeyAvailable; } }
               public override string WindowTitle { get { return Console.Title; } set { Console.Title = WindowTitle; } }
           }
           class UserInterface : PSHostUserInterface
           {
               private PSHostRawUserInterface _rawUi;
               private XS.ScriptContext _c;

               public UserInterface(XS.ScriptContext scriptContext)
               {
                   _c = scriptContext;
                   _rawUi = new RawUi(scriptContext);
               }

               public override string ReadLine()
               {
                   return XS.Utils.HasRealConsole ? Console.ReadLine() : null;
               }

               public override System.Security.SecureString ReadLineAsSecureString()
               {
                   if (!XS.Utils.HasRealConsole)
                       return null;
                   System.Security.SecureString r = new System.Security.SecureString();

                   while (true)
                   {
                       while (!Console.KeyAvailable)
                       {
                           _c.CheckAbort();
                           System.Threading.Thread.Sleep(10);
                       }
                       ConsoleKeyInfo info = Console.ReadKey(true);
                       if (info.Key == ConsoleKey.Enter)
                           break;
                       if (info.Key != ConsoleKey.Backspace)
                       {
                           r.AppendChar(info.KeyChar);
                           _c.Write('*');
                       }
                       else
                       {
                           if (r.Length > 0)
                           {
                               r.RemoveAt(r.Length - 1);
                               _c.Write("\b \b");
                           }
                       }
                   }
                   _c.WriteLine();
                   return r;

               }

               public override void Write(string value) { _c.Write(value); }
               public override void Write(ConsoleColor foregroundColor, ConsoleColor backgroundColor, string value) { _c.Write(value); }
               public override void WriteLine(string value) { _c.WriteLine(value); }
               public override void WriteErrorLine(string value) { _c.Error.WriteLine(value); }
               public override void WriteDebugLine(string message) { _c.Debug.WriteLine(message); }
               public override void WriteProgress(long sourceId, ProgressRecord record) { _c.OnProgress(record.PercentComplete, record.CurrentOperation); }
               public override void WriteVerboseLine(string message) { _c.Info.WriteLine(message); }
               public override void WriteWarningLine(string message) { _c.Info.WriteLine(message); }
               public override Dictionary<string, PSObject> Prompt(string caption, string message, Collection<FieldDescription> descriptions) { throw new NotImplementedException(); }
               public override PSCredential PromptForCredential(string caption, string message, string userName, string targetName) { throw new NotImplementedException(); }
               public override PSCredential PromptForCredential(string caption, string message, string userName, string targetName, PSCredentialTypes allowedCredentialTypes, PSCredentialUIOptions options) { throw new NotImplementedException(); }
               public override int PromptForChoice(string caption, string message, Collection<ChoiceDescription> choices, int defaultChoice) { throw new NotImplementedException(); }
               public override PSHostRawUserInterface RawUI { get { return _rawUi; } }
           }
   
           #endregion
       }
   ?>
</xsharper>