using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.ObjectModel;
using System.Management.Automation;
using System.Management.Automation.Provider;
using System.Management.Automation.Runspaces;



namespace Intel.Management.PSModule.Amt
{
    /// <summary>
  /// This sample implements a Windows PowerShell provider class 
  /// that acts upon AMT Hardware.
  /// </summary>
  /// <remarks>
    /// Get-PSDrive
    /// $DebugPreference = "Continue"
    /// $DebugPreference = "SilentlyContinue"
  /// </remarks>
  [CmdletProvider("AmtSystem", ProviderCapabilities.Credentials)]
  public class AmtDriveProvider : DriveProvider
  {

    
      public AmtDriveProvider()
          : base()
      {
      }

      /// <summary>
      /// The Windows PowerShell engine calls this method when the 
      /// New-PSDrive cmdlet is run and the path to this provider is 
      /// specified. This method creates a connection to the database 
      /// file and sets the Connection property of the PSDriveInfo object.
      /// </summary>
      /// <param name="drive">
      /// Information describing the drive to create.
      /// </param>
      /// <returns>An AmtDriveInfo object that represents 
      /// the new drive.</returns>
      protected override PSDriveInfo NewDrive(PSDriveInfo drive)
      {
          //AmtDriveInfo.AmtDriveParameters localParams = _driveParams;
          //_driveParams=null;
          WriteDebug("AMT NewDrive");
          PSDriveInfo result = null;

          try
          {

              result = new AmtDriveInfo(drive,(AmtDriveParameters)DynamicParameters, this);

          }
          catch (PSArgumentException argException)
          {
              WriteError(new ErrorRecord(
                        argException,
                        argException.GetType().Name,
                        ErrorCategory.InvalidArgument,
                        PSDriveInfo));
          }
          catch (Intel.Management.Wsman.WsmanUnauthorizedException authException)
          {
              WriteError(new ErrorRecord(
                        authException,
                        authException.GetType().Name,
                        ErrorCategory.PermissionDenied,
                        PSDriveInfo));
          }
         
          return result;
      }

      protected override object NewDriveDynamicParameters()
      {
          return new AmtDriveParameters();
      }

      //private Collection<PSDriveInfo> _drives;


      /// <summary>
      /// When the provider engine starts a provider, the InitializeDefaultDrives method 
      /// is called. This is an opportunity for the provider to mount drives that are 
      /// important to it.
      /// </summary>
      /// <returns>A collection of PSDriveInfo objects for each drive the provider
      /// wants to mount.</returns>
     /* protected override Collection<PSDriveInfo> InitializeDefaultDrives()
      {

         /* if (_drives == null)
          {
              WriteDebug("Initializing amt drive");
              _drives = new Collection<PSDriveInfo>();
              _drives.Add(new PSDriveInfo("AMT", ProviderInfo, "Config",
                  "Intel(r) AMT Subsystem", Credential));
          }


      }*/





      /// <summary>
      /// The Windows PowerShell engine calls this method when the 
      /// Remove-PSDrive cmdlet is run and the path to this provider is 
      /// specified. This method closes a hardware connection
      /// </summary>
      /// <param name="drive">The drive to remove.</param>
      /// <returns>An AMTDrive object that represents 
      /// the removed drive.</returns>
      protected override PSDriveInfo RemoveDrive(PSDriveInfo drive)
      {
          return drive;
      } // End RemoveDrive.

    


  


      /*
   
    /// <summary>
    /// Definition of an AmtDriveInfo object
    /// </summary>
    internal class AmtDriveInfo : PSDriveInfo
    {
        AmtDriveItem _root;
        HECIClass _heci;

        string _cashedPath;
        AmtDriveItem _cashedItem;

        bool _bDriverLoaded;
        bool _bDriverLocked;
        
        public AmtDriveInfo(PSDriveInfo info) : base(info)
        {
        
           _heci = new HECIClass();
           _cashedItem = null;
           _cashedPath = string.Empty;

            //_root = new ContainerItem("LocalDriver",
           _root = new AmtRootItem(_heci);
           _bDriverLoaded = false;
        }

        public void LockDriver()
        {
            _bDriverLocked=true;
        }

        public void UnlockDriver()
        {
            _bDriverLocked = false;
            UnLoadDriver();
        }

        public void LoadDriver()
        {
            if (!_bDriverLoaded)
            {
                _heci.Init();
                _bDriverLoaded = true;
            }
        }

        public void UnLoadDriver()
        {
            if (_bDriverLoaded && !_bDriverLocked)
            {
                _heci.DeInit();
                _bDriverLoaded = false;
            }
        }
        
        public AmtDriveItem GetItemFromPath(string path)
        {
            //check root
            if (string.IsNullOrEmpty(path) ||
                string.Compare(this.Name,path,true)==0 ||
                string.Compare(this.Name+"\\", path, true)==0)
            {
                return _root;
            }

          

            // Get path components
            char[] splits = {'\\'};
            string[] paths = path.Split(splits, StringSplitOptions.RemoveEmptyEntries);
            
            //find item in path
            AmtDriveItem parent = _root;
            AmtDriveItem foundItem = null;

            //load heci if its in the path
            foreach (string pathItem in paths)
            {
                if (string.Compare(pathItem, AmtHeciRootItem.HostDriveName, true) == 0)
                    LoadDriver();

            }

            //check and see if the item is cached
            if (string.Compare(path, _cashedPath, true) == 0)
            {
                return _cashedItem;
            }
            else
            {
                //check if parent is cached
                int pos = path.ToLower().IndexOf(_cashedPath.ToLower() + "\\");
                if (pos == 0)
                {
                    paths = path.Substring(_cashedPath.Length).Split(splits, StringSplitOptions.RemoveEmptyEntries);
                    parent = _cashedItem;
                }
            }

            try
            {
                
                for (int i = 0; i < paths.Length; i++)
                {
                    foundItem = null;
                                      
                    foreach (AmtDriveItem childItem in parent.GetChildItems())
                    {
                        if (string.Compare(childItem.Name, paths[i], true) == 0)
                        {
                            foundItem = childItem;
                            parent = foundItem;
                            break;
                        }
                    }

                    if (foundItem == null)
                    {
                        break;
                    }
                    else
                    {
                        _cashedItem = foundItem;
                        _cashedPath = path;
                    }
                }

            }
            finally
            {
                UnLoadDriver();
            }

            


           
            return foundItem;
        }
    }
    // End defintion of AMTDriveInfo


    internal class AmtRootContainerValue : ContainerItemValue
    {
        AmtDriveItem[] _items;
       

        public AmtRootContainerValue(HECIClass heci)
        {
            //build the array
            _items = new AmtDriveItem[1];
            _items[0]= new AmtHeciRootItem(heci);
        }

        public override AmtDriveItem[] GetChildItems()
        {
            return _items;
        }
    }

    /// <summary>
    /// Definition of the Root Container
    /// </summary>
    internal class AmtRootItem : AmtDriveItem
    {

        AmtRootContainerValue _value;

        public AmtRootItem(HECIClass heci)
        {
            _value = new AmtRootContainerValue(heci);
        }

        public override string Name
        {
            get
            {
                return DriveName;
            }
        }

        public override object  Value
        {
            get
            {
                return _value;
            }
        }

        public override bool HasChildren
        {
            get
            {
                return true;
            }
        }

   

        public static string DriveName
        {
            get
            {
                return "AMT";
            }
        }
       
    }
    //End Definition of the Root Container

    internal class AmtSetupContainerValue : ContainerItemValue
    {
          HECIClass _heci;

        public AmtSetupContainerValue(HECIClass heci)
        {
            _heci = heci;
        }

        public override AmtDriveItem[] GetChildItems()
        {
            List<AmtDriveItem> list = new List<AmtDriveItem>();

            HECIClass.ProvisioningMode mode;
            bool bOk = _heci.GetProvisioningMode(out mode);
            if (bOk)
                list.Add(new AmtPropertyItem("ProvisioningMode", mode));

            bool ztcEnabled;
            bOk = _heci.GetZeroTouchEnabled(out ztcEnabled);
            if (bOk)
                list.Add(new AmtPropertyItem("ZeroTouch", ztcEnabled));

            HECIClass.TlsMode tlsMode;
            bOk = _heci.GetTlsMode(out tlsMode);
            if (bOk)
                list.Add(new AmtPropertyItem("SetupMode", tlsMode));

            HECIClass.RngSeedStatus rngStatus;
            bOk = _heci.GetRngSeedStatus(out rngStatus);
            if (bOk)
                list.Add(new AmtPropertyItem("RngStatus", rngStatus));

            return list.ToArray();
        }
    }


     /// <summary>
    /// Definition of the setup container
    /// </summary>
    internal class AmtSetupItem : AmtDriveItem
    {

        AmtSetupContainerValue _value;
        public AmtSetupItem(HECIClass heci)
        {
            _value = new AmtSetupContainerValue(heci);
        }


        public override bool HasChildren
        {
            get
            {
                return true;
            }
        }

   
        public override string Name
        {
            get
            {
                return "LegacySetup";
            }
        }

        public override object Value
        {
            get
            {
                return _value;
            }
        }
    }

    /// <summary>
    /// Definition of an individual hash item
    /// </summary>
    internal class AmtHashEntryItem : AmtDriveItem
    {
        AmtHashContainerValue _value;

        public AmtHashEntryItem(HECIClass.HashEntry entry)
        {
            _value = new AmtHashContainerValue(entry);
        }

      
        public override bool HasChildren
        {
            get
            {
                return true;
            }
        }

    
        public override string Name
        {
            get
            {
                return _value.Name;
            }
        }

        public override object Value
        {
            get
            {
                return _value;
            }
        }
    }
    // Definition of an Hash Entry Item


     /// <summary>
    /// Container value for a Hash Entry
    /// </summary>
    internal class AmtHashContainerValue : ContainerItemValue
    {
        HECIClass.HashEntry _entry;

        public AmtHashContainerValue(HECIClass.HashEntry entry)
        {
            _entry = entry;
        }

        public string Name
        {
            get
            {
                return _entry.Name;
            }
        }

        public override AmtDriveItem[] GetChildItems()
        {
            List<AmtDriveItem> list = new List<AmtDriveItem>();

            list.Add(new AmtPropertyItem("Name", _entry.Name));
            list.Add(new AmtPropertyItem("IsDefault", _entry.IsDefault));
            list.Add(new AmtPropertyItem("IsActive", _entry.IsActive));
            list.Add(new AmtPropertyItem("Thumbprint", _entry.Thumbprint));
            list.Add(new AmtPropertyItem("HashString", _entry.HashString));

            return list.ToArray();
        }

        public override string ToString()
        {
            return _entry.Thumbprint;
        }
    }


    /// <summary>
    /// Container value for Hashes
    /// </summary>
    internal class AmtHashesContainerValue : ContainerItemValue
    {
        HECIClass _heci;

        public AmtHashesContainerValue(HECIClass heci)
        {
            _heci = heci;
        }

        public override AmtDriveItem[] GetChildItems()
        {
            HECIClass.HashEntry[] hashes;
            AmtDriveItem[] result = { };
            if (_heci.GetCertHashes(out hashes))
            {
                result = new AmtDriveItem[hashes.Length];
                for (int i = 0; i < hashes.Length; i++)
                {
                    result[i] = new AmtHashEntryItem(hashes[i]);
                }
            }
            return result;
        }
    }



    /// <summary>
    /// Definition of a collection of hashes
    /// </summary>
    internal class AmtHashesItem : AmtDriveItem
    {
        AmtHashesContainerValue _value;
        bool _hasChildren;

        public AmtHashesItem(HECIClass heci) : base() 
        {
            _value = new AmtHashesContainerValue(heci);
            _hasChildren = false;
        }

        public override bool IsContainer
        {
            get
            {
                return true;
            }
        }

        public override bool HasChildren
        {
            get
            {
                return _hasChildren;
            }
        }

        public override AmtDriveItem[] GetChildItems()
        {
            AmtDriveItem[] result = _value.GetChildItems();

           _hasChildren = result.Length > 0;

            return result;
        }

        public override string Name
        {
            get
            {
                return "Hashes";
            }
        }

        public override object Value
        {
            get
            {
                return _value;
            }
        }
    }

    /// <summary>
    /// Container value for Root Heci Items
    /// </summary>
    internal class AmtHeciContainerValue : ContainerItemValue
    {
        HECIClass _heci;

        public AmtHeciContainerValue(HECIClass heci)
        {
            _heci = heci;
        }

        public override AmtDriveItem[] GetChildItems()
        {
            List<AmtDriveItem> list = new List<AmtDriveItem>();

            bool bOk;
            string boisString;


            HECIClass.ProvisioningState state;
            bOk = _heci.GetProvisioningState(out state);
            if (bOk)
                list.Add(new AmtPropertyItem("ProvisioningState", state));


            HECIClass.AMT_VERSION_TYPE[] verTypes;
            bOk = _heci.GetCodeVersions(out boisString, out verTypes);
            if (bOk)
            {

                list.Add(new AmtPropertyItem("BIOSVersion", boisString));
                foreach (HECIClass.AMT_VERSION_TYPE verType in verTypes)
                {
                    list.Add(new AmtPropertyItem(verType.Description.Text,
                        verType.Version.Text));
                }
            }


            string userName, password;
            bOk = _heci.GetLocalAdminCredentials(out userName, out password);
            if (bOk)
            {
                list.Add(new AmtPropertyItem("LocalUser", userName));
                list.Add(new AmtPropertyItem("LocalPassword", password));
            }

            list.Add(new AmtPropertyItem("LocalAddress", "http://localhost:16992/wsman"));


            list.Add(new AmtSetupItem(_heci));
            list.Add(new AmtHashesItem(_heci));

            return list.ToArray();
        }
    }
    //Container value for Root Heci Items

    /// <summary>
    /// Definition of the Heci Root Item
    /// </summary>
    internal class AmtHeciRootItem : AmtDriveItem
    {
        AmtHeciContainerValue _value;
        public AmtHeciRootItem(HECIClass heci) 
        {
            _value = new AmtHeciContainerValue(heci);
        }


        public override bool HasChildren
        {
            get
            {
                return true;
            }
        }

        public override string Name
        {
            get
            {
                return HostDriveName;
            }
        }

        public override object Value
        {
            get
            {
                return _value;
            }
        }

        public static string HostDriveName
        {
            get
            {
                return "HostDriver";
            }
        }
    }

    /// <summary>
    /// Definition a property item
    /// </summary>
    internal class AmtPropertyItem : AmtDriveItem
    {
        string _name;
        object _value;
       
        public AmtPropertyItem(string name, object value) : base()
        {
            _name = name;
            _value = value;
        }

        public override string Name
        {
            get
            {
                return _name;
            }
        }

        public override object Value
        {
            get
            {
                return _value;
            }
        }
    }*/

  } //End AMTDriveProvider

 
} // end Namepsace