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 Intel.Management.Wsman;


namespace Intel.Management.Module.Amt
{


    class StorageManager
    {

        class RegistrationsContainer : DriveContainer
        {
            StorageManager _stgManager;
     

            public RegistrationsContainer(StorageManager stgManager)
                : base("Registrations")
            {
                _stgManager = stgManager;
                _items = null;           
            }

            public override ManagedItem[] GetChildItems(bool force)
            {
                if (_items == null)
                {
                    List<ManagedItem> list = new List<ManagedItem>();

                    IManagedInstance outObj=_stgManager.GetRegisteredApplications();

                    //_stgManager.get
                    //list.Add(new AppDataContainer(_stgManager));

                    //list.Add(new EnterpriseContainer(_stgAdmin));
                    //list.Add(new PartnerContainer(_stgAdmin));
                    //list.Add(new RegistrationsContainer(_stgAdmin));

                    list.Sort(_defaultComparer);
                    _items = list.ToArray();
                }
                return _items;
            }
        }

        class BlockItem : DriveItem
        {
            StorageManager _stgManager;
            Dictionary<string, object> _props;

            public BlockItem( StorageManager stgManager,string handle)
                : base(handle, ManagedValueType.Resource)
            {
                _stgManager = stgManager;

                IManagedInstance outObj= _stgManager.GetBlockAttributes(handle);

                _name=outObj.GetProperty("BlockHidden").ToString();
                _props = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
                _props.Add("BlockSize", uint.Parse( outObj.GetProperty("BlockSize").ToString() ));
                _props.Add("BlockHidden", bool.Parse(outObj.GetProperty("BlockHidden").ToString()));
                _props.Add("BlockHandle", uint.Parse(handle));

                _name = outObj.GetProperty("BlockName").ToString();
            }

            public override string[] Properties
            {
                get
                {
                    return _props.Keys.ToArray();
                }
            }

            public override object GetProperty(Collection<string> propList, bool force)
            {
                return GetProperties(_props, propList);
            }
        }

       


        class BlockContainer : DriveContainer
        {

            StorageManager _stgManager;
            uint _owner;
       
          
            public BlockContainer(StorageManager stgManager,uint owner)
                : base("Blocks")
            {
                _stgManager = stgManager;
                _owner = owner;
                _items = null;

            }

            public override ManagedItem[] GetChildItems(bool force)
            {
                if (_items == null || force)
                {
                    List<ManagedItem> list = new List<ManagedItem>();

                    IManagedInstance outObj = _stgManager.GetAllocatedBlocks(_owner.ToString());

                    IWsmanItem handles = outObj.GetProperty("BlockHandles");
                    if (handles != null)
                    {
                        foreach (IWsmanItem handle in handles)
                        {
                            list.Add(new BlockItem(_stgManager, handle.ToString()));
                        }
                    }

                    list.Sort(_defaultComparer);
                    _items = list.ToArray();
                }
                return _items;
            }
        }


        public class StorageWriter : IContentWriter 
        {

           

            public void Dispose()
            {
            }

            public void Close()
            {
               

            }

            public void Seek(long offset, System.IO.SeekOrigin origin)
            {
                //Microsoft.PowerShell.Commands.FileSystemCmdletProviderEncoding.
            }

            public System.Collections.IList Write(System.Collections.IList content)
            {

                object b=content[0];
                if (b is PSObject)
                {
                    PSObject bb = b as PSObject;
                    //bb.
                    bb.ToString();
                }
                //content.
                return content;
            }
        }


        class SessionContainer : DriveContainer
        {
            StorageManager _stgManager;
            static string[] _propKeys = { "BytesAvailable", "SessionHandle", "ApplicationHandle" , "VendorName", "ApplicationName", };


            public SessionContainer(StorageManager stgManager, string name)
                : base(name)
            {
                _stgManager = stgManager;
                _items = null;
                
            }

            public override string[] Properties
            {
                get { return _propKeys; }
               
            }


            public override ManagedItem[] GetChildItems(bool force)
            {
                if (_items == null)
                {
                    List<ManagedItem> list = new List<ManagedItem>();

                    list.Add(new BlockContainer(_stgManager,_stgManager.ApplicationHandle));
                   
                    list.Add(new RegistrationsContainer(_stgManager));

                    list.Sort(_defaultComparer);
                    _items = list.ToArray();
                }
                return _items;
            }

            public override object GetProperty(Collection<string> propList, bool force)
            {
                Dictionary<string, object> props = 
                    new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

                props.Add("SessionHandle",_stgManager.SessionHandle);
                props.Add("ApplicationHandle",_stgManager.ApplicationHandle);

                if (HasProperty(propList,"BytesAvailable"))
                    props.Add("BytesAvailable",_stgManager.GetBytesAvailable());

                if (HasProperty(propList, "VendorName") || HasProperty(propList, "ApplicationName"))
                {
                
                    IManagedInstance outObj = _stgManager.GetApplicationAttributes();
                    props.Add("VendorName", outObj.GetProperty("VendorName").ToString());
                    props.Add("ApplicationName", outObj.GetProperty("ApplicationName").ToString());
                }
                return GetProperties(props, propList);
            }

                 
            public override void RemoveItem(object dynamicParams, bool force)
            {
                _stgManager.UnregisterApplication();
                _stgManager.RemoveItem(this);
            }

            public override IContentWriter GetContentWriter(object dynamicParams, bool force)
            {
                return new StorageWriter();
            }

           /* public override g
            {
                return null;
            }

            public IContentWriter GetContentWriter(string path)
            {
                return null;
            }*/

            //public override set

        }


        class SetContentDynamicParameters
        {
            public SetContentDynamicParameters()
            {
                _encoding = Microsoft.PowerShell.Commands.FileSystemCmdletProviderEncoding.Unknown;
            }

            [Parameter(Mandatory = false, HelpMessage = "Encoding type of the content")]
            public Microsoft.PowerShell.Commands.FileSystemCmdletProviderEncoding Encoding
            {
                get { return _encoding; }
                set { _encoding = value; }
            }

            [Parameter(Mandatory = false, HelpMessage = "Encoding type of the content")]
            public uint BlockHandle
            {
                get { return _blockHandle; }
                set { _blockHandle = value; }
            }

            [Parameter(Mandatory = false, HelpMessage = "Encoding type of the content")]
            public uint AllocationSize
            {
                get { return _allocationSize; }
                set { _allocationSize = value; }
            }


            Microsoft.PowerShell.Commands.FileSystemCmdletProviderEncoding _encoding;
            uint _blockHandle;
            uint _allocationSize;

        }

        class SessionDynamicParameters
        {
            public SessionDynamicParameters()
            {
                _uuid=Guid.Empty;
            }

            [Parameter(Mandatory = true, Position = 0, HelpMessage = "Vendor Name of the Storage ACL")]
            public string VendorName
            {
                get { return _vendorName;}
                set {_vendorName=value; }
            }

            [Parameter(Mandatory = true, Position = 1, HelpMessage = "Application Name of the Storage ACL")]
            public string ApplicationName
            {
                get { return _appName;}
                set { _appName=value;}
            }

            [Parameter(Mandatory = true, Position = 2, HelpMessage = "Enterprise Storage ACL")]
            public string EnterpriseName
            {
                get { return _entName;}
                set {_entName=value;}
            }

            [Parameter(Mandatory = false, Position = 3, HelpMessage = "UUID of the comupter accessing storage")]
            public Guid UUID
            {
                get {return _uuid;}
                set{_uuid=value;}
            }


            string _appName;
            string _vendorName;
            string _entName;
            Guid _uuid;
        }

        class StorageRoot : DriveContainer
        {
            StorageManager _stgManager;
   
            static string[] _propNames = { "Mtu", "WriteEraseLimit", "RegistrationTimeout", "LockTimeout" };

            public StorageRoot(StorageManager stgManager)
                : base("Third Party Data Storage")
            {
                _stgManager = stgManager;
               
            }

            public override string[] Properties
            {
                get { return _propNames; }
            }

            public override object GetProperty(Collection<string> propList, bool force)
            {
                Dictionary<string, object> props = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

                props.Add("Mtu", _stgManager.Mtu);
                props.Add("WriteEraseLimit",_stgManager.GetWriteEraseLimit());

                uint regTimeout, lockTimeout;
                _stgManager.GetTimeoutValues(out regTimeout, out lockTimeout);
                
                props.Add("RegistrationTimeout",regTimeout);
                props.Add("LockTimeout",  lockTimeout);

                return GetProperties(props, propList);
            }

            public override ManagedItem NewItem(string name, string type, object newItem, object dynamicParams, bool force)
            {
                SessionDynamicParameters sessionParams = dynamicParams as SessionDynamicParameters;

                StorageManager stgManager = new StorageManager(_stgManager);

                stgManager.RegisterApplication(sessionParams.VendorName,
                                sessionParams.ApplicationName,
                                sessionParams.EnterpriseName,
                                sessionParams.UUID);

                List<ManagedItem> list = new List<ManagedItem>(_items);

                ManagedItem itemToAdd = new SessionContainer(stgManager,name);
                list.Add(itemToAdd);
                _items = list.ToArray();

                return (DriveItem)itemToAdd;
            }
            
            public override object NewItemDynamicParameters(string itemTypeName, object newItemValue)
            {
                return new SessionDynamicParameters();
            }
        }



        public class StorageOperationException : Exception
        {
            public StorageOperationException(string message) : base(message) { }

            public static void CheckResult(IManagedInstance resultObj)
            {
                string returnValue = resultObj.GetProperty("ReturnValue").ToString();
                if (!returnValue.Equals("0"))
                {
                    throw new StorageOperationException(resultObj.SimpleName + ".ReturnValue=" + returnValue);
                }
            }
        }


        // private data
        IManagedReference _storageRef;
        string _sessionHandle;
        uint _appHandle;
        uint _mtu;

        DriveContainer _root;
              
        public StorageManager(WsmanConnection conn) 
        {
            _storageRef = conn.NewReference("AMT_ThirdPartyDataStorageService");
            _root = new StorageRoot(this);
  
        }

        // copy constuctor
        public StorageManager(StorageManager stgManager)
        {
            _storageRef = stgManager._storageRef;
            _appHandle = stgManager._appHandle;
            _sessionHandle = stgManager.SessionHandle;
            _root = stgManager._root;
            _mtu = stgManager._mtu;
        }

        public ManagedItem RootFolder
        {
            get { return _root; }
        }

        private bool RemoveItem(DriveItem item)
        {
            return _root.RemoveChildItem(item, true);
        }

        private uint Mtu
        {
            get
            {
                if (_mtu == 0)
                    _mtu = GetMtu();
                return Mtu;
            }
        }


        private string SessionHandle
        {
            get { return _sessionHandle;  }
            set { _sessionHandle = value; }
        }

        private uint ApplicationHandle
        {
            get { return _appHandle; }
            set {_appHandle = value; }
        }

        private uint GetMtu()
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("GetMTU");
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            return uint.Parse( outObj.GetProperty("Mtu").ToString() );
        }

        void RegisterApplication(string appName, string vendorName,string entName, Guid uuid)
        {
            string uuidString = BitConverter.ToString(uuid.ToByteArray());
            uuidString = uuidString.Replace("-", ""); 

            IManagedInstance inputObj = _storageRef.CreateMethodInput("RegisterApplication");
            inputObj.SetProperty("CallerUUID",uuidString );
            inputObj.SetProperty("VendorName", vendorName);
            inputObj.SetProperty("ApplicationName", appName);
            inputObj.SetProperty("EnterpriseName", entName);
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            _sessionHandle= outObj.GetProperty("SessionHandle").ToString();
            GetCurrentApplicationHandle();
        }

        void UnregisterApplication()
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("UnregisterApplication");
            inputObj.SetProperty("SessionHandle", _sessionHandle);
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
        }

        private uint GetWriteEraseLimit()
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("GetWriteEraseLimit");
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            return uint.Parse(outObj.GetProperty("WriteEraseLimit").ToString());
        }

        private void GetTimeoutValues(out uint regTimeout, out uint lockTimeout)
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("GetTimeoutValues");
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            regTimeout = uint.Parse(outObj.GetProperty("RegistrationTimeout").ToString());
            lockTimeout = uint.Parse(outObj.GetProperty("LockTimeout").ToString());
        }

        private uint GetBytesAvailable()
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("GetBytesAvailable");
            inputObj.SetProperty("SessionHandle", _sessionHandle);
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            return uint.Parse(outObj.GetProperty("BytesAvailable").ToString());
            
        }


        private IManagedInstance AllocateBlock(uint size,bool hidden,string name)
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("AllocateBlock");
            inputObj.SetProperty("SessionHandle", _sessionHandle);
            inputObj.SetProperty("BytesRequested", size.ToString());
            inputObj.SetProperty("BlockHidden", hidden.ToString().ToLower());
            //inputObj.SetProperty("BlockName", name);

            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            return outObj;
        }

        private IManagedInstance GetAllocatedBlocks(string owner)
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("GetAllocatedBlocks");
            inputObj.SetProperty("SessionHandle",_sessionHandle);
            inputObj.SetProperty("BlockOwnerApplication", owner);
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            return outObj;
        }

        private IManagedInstance GetBlockAttributes(string handle)
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("GetBlockAttributes");
            inputObj.SetProperty("SessionHandle", _sessionHandle);
            inputObj.SetProperty("BlockHandle", handle);
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            return outObj;
        }

        private uint WriteBlock(string handle,uint offset,byte[] data)
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("GetBlockAttributes");
            inputObj.SetProperty("SessionHandle", _sessionHandle);
            inputObj.SetProperty("BlockHandle", handle);
            inputObj.SetProperty("ByteOffset",offset.ToString());
            inputObj.SetProperty("Data", Convert.ToBase64String(data));
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            return uint.Parse(outObj.GetProperty("BytesWritten").ToString());
        }
        
        private uint GetCurrentApplicationHandle()
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("GetCurrentApplicationHandle");
            inputObj.SetProperty("SessionHandle",_sessionHandle);
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            return _appHandle= uint.Parse(outObj.GetProperty("ApplicationHandle").ToString());
        }

        private IManagedInstance GetRegisteredApplications()
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("GetRegisteredApplications");
            inputObj.SetProperty("SessionHandle", _sessionHandle);
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            return outObj;
        }

        private IManagedInstance GetApplicationAttributes()
        {
            IManagedInstance inputObj = _storageRef.CreateMethodInput("GetApplicationAttributes");

            inputObj.SetProperty("SessionHandle", _sessionHandle);
            inputObj.SetProperty("ApplicationBeingRequested", _appHandle.ToString());
                                  
            IManagedInstance outObj = _storageRef.InvokeMethod(inputObj);
            StorageOperationException.CheckResult(outObj);
            return outObj;
        }
        
     
      

        


    }
}