using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Reflection;
using Intel.Management.Wsman;

namespace Intel.Management.PSModule.Amt
{
    class InventoryService : DriveContainer
    {


        public InventoryService(DriveItem parent) :
            base("HardwareAssets", parent)
        {

            _items = null;
        }


        public override void GetChildItems(ChildWriter writer)
        {
            writer.Add(new Bios(this));
            writer.Add(new Baseboard(this));
            writer.Add(new ComputerSystem(this));
            writer.Add(new Memory(this));
            writer.Add(new Fru(this));
            writer.Add(new Cpu(this));

            //wrtier.Add(new Cooling(this));     
        }

        IWsmanEnumeration ExecQuery(string query)
        {
            IWsmanConnection conn = ((AmtRootService)GetRoot()).Connection;
            return conn.ExecQuery(query);
        }

        public override object GetReturnObject()
        {
            return new NameValuePairItem(Name, Value);
        }
       
      /*  class Container
        {
            public override string ToString()
            {
                return "Container";
            }
        }*/


        class HardwareItem : DriveContainer
        {
        
            public HardwareItem(string name,DriveItem parent)
                : base(name, parent)
            {
                _value = new Container();
            }


            public void AddValues(string[] values,IManagedInstance itemObj)
            {
                List<DriveItem> list = GetChildList();
                foreach (string name in values)
                {
                    IWsmanItem result = itemObj.GetProperty(name);
                    if (!result.IsNull && result.IsString)
                        list.Add(new DriveEntry(name,result.ToString(),this));
                    else if (!result.IsNull && result.IsObject)
                        list.Add(new DriveEntry(name, 
                            AmtDriveInfo.FormatDate(result), this));
                }
                _items=list.ToArray();
            }


            public void AddValues(string[] values, IManagedInstance itemObj, Type type)
            {
                List<DriveItem> list = GetChildList();
                foreach (string name in values)
                {
                    IWsmanItem result = itemObj.GetProperty(name);
                    if (!result.IsNull && result.IsString)
                    {
                        //on the type object find a parse string method
                        Type[] types={typeof(string)};
                        object[] methodParams={result.ToString()};
                        MethodInfo parseInfo=type.GetMethod("Parse", types);

                        if (parseInfo != null)
                            list.Add(new DriveEntry(name, parseInfo.Invoke(type, methodParams), this));
                        else
                            list.Add(new DriveEntry(name, result.ToString(), this));
                    }
                 
                }
                _items = list.ToArray();
            }

            public override object GetReturnObject()
            {
                return new NameValuePairItem(Name, Value);
            }
        }// end hardware item

        class Bios : DriveContainer
        {
            public Bios(DriveItem parent)
                : base("BIOS", parent)
            {
                _items = null;
                _value = new Container();
            }


            public override void GetChildItems(ChildWriter writer)
            {
                InventoryService service = (InventoryService)Parent;
           
                //Read BIOS information
                //Select PartComponent From CIM_SystemBIOS
                IWsmanEnumeration colObj = service.ExecQuery("SELECT * FROM CIM_SystemBIOS");
                foreach (IWsmanItem item in colObj)
                {
                    //get the BIOS element 
                    IManagedInstance biosObj = item.Object.GetProperty("PartComponent").Ref.Get();

                    HardwareItem newBios = new HardwareItem(biosObj.GetProperty("ElementName").ToString(), this);
                    string[] biosValues = { "Version","ReleaseDate","Manufacturer"};
                    newBios.AddValues(biosValues,biosObj);

                    writer.Add(newBios);
                  
                    
                    IWsmanEnumeration features = service.ExecQuery("SELECT * FROM CIM_BIOSFeatureBIOSElements");
                    foreach (IWsmanItem elements in features)
                    {
                        IManagedInstance partObj = elements.Object.GetProperty("PartComponent").Ref.Get();
                        if (partObj.GetProperty("Name").ToString().Equals(biosObj.GetProperty("Name").ToString()))
                        {
                            IManagedInstance groupObj = elements.Object.GetProperty("GroupComponent").Ref.Get();

                            HardwareItem newFeature = new HardwareItem(
                                groupObj.GetProperty("ElementName").ToString(), this);

                            string[] featureValues = { "Characteristics" };
                            newFeature.AddValues(featureValues, groupObj);

                            writer.Add(newFeature);
                        }
                    } //for each feature
                }// foreach Bios
            }//end GetChildern

            public override object GetReturnObject()
            {
                return new NameValuePairItem(Name, Value);
            }
        }//End Bios Class


        class Baseboard : DriveContainer
        {
            public Baseboard(DriveItem parent)
                : base("Baseboard", parent)
            {
                _items = null;
                _value = new Container();
            }


            public override void GetChildItems(ChildWriter writer)
            {
                InventoryService service = (InventoryService)Parent;

                //Read MotherBoard Information -Select From CIM_Card 
                IWsmanEnumeration colObj = service.ExecQuery("SELECT * FROM CIM_Card");
                foreach (IWsmanItem item in colObj)
                {

                    HardwareItem newItem = new HardwareItem(
                        item.Object.GetProperty("ElementName").ToString(),
                        this);

                    string[] boardValues = { "Manufacturer", "Model", "Version", "SerialNumber", "Tag" };
                    newItem.AddValues(boardValues, item.Object);

                    writer.Add(newItem);
                  
                }//foreach card
            }

            public override object GetReturnObject()
            {
                return new NameValuePairItem(Name, Value);
            }
        }//End BaseBoard Class

        class ComputerSystem : DriveContainer
        {
            public ComputerSystem(DriveItem parent)
                : base("ComputerSystem", parent)
            {
                _items = null;
                _value = new Container();
            }

            public override void GetChildItems(ChildWriter writer)
            {
                InventoryService service = (InventoryService)Parent;

            
                //Read Chassis information - Select From CIM_ComputerSystemPackage
                IWsmanEnumeration colObj = service.ExecQuery("SELECT * FROM CIM_ComputerSystemPackage");
                foreach (IWsmanItem item in colObj)
                {
                    IManagedInstance compObj = item.Object.GetProperty("Dependent").Ref.Get();

                    DriveItem newItem = new DriveEntry(compObj.GetProperty("Name").ToString(),
                        AmtDriveInfo.FormatGuid(item.Object.GetProperty("PlatformGUID").ToString()), this);
                    writer.Add(newItem);
               
                  //Read Chassis information - Select From CIM_ComputerSystemPackage
                    IManagedInstance chasObj = item.Object.GetProperty("Antecedent").Ref.Get();

                    HardwareItem newChas = new HardwareItem("  ", this);
                    string[] boardValues = { "Model", "Manufacturer", "Version", "SerialNumber" };
                    newChas.AddValues(boardValues,chasObj);

                    writer.Add(newChas);



                 }

               
            }

            public override object GetReturnObject()
            {
                return new NameValuePairItem(Name, Value);
            }

           
        }//end ComputerSystem
      
        class PowerSupply : DriveContainer
        {
            public PowerSupply(DriveItem parent)
                : base("PowerSupply", parent)
            {
                _items = null;
                _value = new Container();
            }


            public override void GetChildItems(ChildWriter writer)
            {
                InventoryService service = (InventoryService)Parent;
                
                //Read PowerSupply information - Select From CIM_PowerSupply 
                IWsmanEnumeration colObj = service.ExecQuery("SELECT * FROM CIM_PowerSupply");
                foreach (IWsmanItem item in colObj)
                {
                    //ProcessItem(new HardwareItem(service, item.Object, this),
                    //   list, provider, path, recurse);
                }
            }

            public override object GetReturnObject()
            {
                return new NameValuePairItem(Name, Value);
            }
           

        }//end PowerSupply class

        class Cooling : DriveContainer
        {
            public Cooling(DriveItem parent)
                : base("Cooling", parent)
            {
                _items = null;
                _value = new Container();
            }


            public override void GetChildItems(ChildWriter writer)
            {
                InventoryService service = (InventoryService)Parent;


                //Read cooling device information
                IWsmanEnumeration colObj = service.ExecQuery("SELECT * FROM CIM_Fan");
                foreach (IWsmanItem item in colObj)
                {
                    // ProcessItem(new HardwareItem(service, item.Object, this),
                    //    list, provider, path, recurse);
                }
            }

            public override object GetReturnObject()
            {
                return new NameValuePairItem(Name, Value);
            }

        }// end Cooling class


        class Fru : DriveContainer
        {
            public Fru(DriveItem parent)
                : base("FRU", parent)
            {
                _items = null;
                _value = new Container();
            }


            public override void GetChildItems(ChildWriter writer)
            {
                InventoryService service = (InventoryService)Parent;
                
                //Read PCI device Information - Select from AMT_PCIDevice
                IWsmanEnumeration colObj = service.ExecQuery("SELECT * FROM AMT_PCIDevice");
                foreach (IWsmanItem item in colObj)
                {
                    HardwareItem newItem = new HardwareItem(
                        item.Object.GetProperty("DeviceID").ToString(), this);

                    string[] values ={"VendorID","RevisionID","ProgIf","Subclass",
                                            "ClassCode","SubsystemVendorID","SubsystemID",
                                            "DeviceLocation"};

                    newItem.AddValues(values, item.Object);

                    writer.Add(newItem);
                }
            }

            public override object GetReturnObject()
            {
                return new NameValuePairItem(Name, Value);
            }


        }//end Fru class

        class Memory : DriveContainer
        {
            public Memory(DriveItem parent)
                : base("Memory", parent)
            {
                _items = null;
                _value = new Container();
            }

            public override void GetChildItems(ChildWriter writer)
            {
                InventoryService service = (InventoryService)Parent;
                
                //Read Processor Information 
                IWsmanEnumeration colObj = service.ExecQuery("SELECT * FROM CIM_Memory");

                foreach (IWsmanItem item in colObj)
                {
                    HardwareItem newItem = new HardwareItem(
                            item.Object.GetProperty("DeviceID").ToString(),
                            this);


                    ValueMap valueMap = ValueMap.Create(
                            item.Object.GetProperty("Access").ToString(),
                            ValueList.MemoryAccess);

                    newItem.AddChildItem(new DriveEntry("Access", valueMap, newItem));

                    newItem.AddChildItem(new DriveEntry("ConsumableBlocks",
                        ulong.Parse(item.Object.GetProperty("ConsumableBlocks").ToString()),
                        newItem));

                    newItem.AddChildItem(new DriveEntry("BlockSize",
                        ulong.Parse(item.Object.GetProperty("BlockSize").ToString()),
                        newItem));

                    newItem.AddChildItem(new DriveEntry("NumberOfBlocks",
                       ulong.Parse(item.Object.GetProperty("NumberOfBlocks").ToString()),
                       newItem));

                    newItem.AddChildItem(new DriveEntry("Volatile",
                       bool.Parse(item.Object.GetProperty("Volatile").ToString()),
                       newItem));

                    writer.Add(newItem);

                    HardwareItem newDevices = new HardwareItem(
                        "Devices",
                        this);

                    IWsmanEnumeration memDevices = service.ExecQuery("SELECT * FROM CIM_PhysicalMemory");

                    foreach (IWsmanItem deviceObj in memDevices)
                    {
                        HardwareItem newDevice = new HardwareItem(
                           deviceObj.Object.GetProperty("Tag").ToString(),
                           this);

                        string[] values = { "Tag", "BankLabel", "PartNumber", "SerialNumber", "Manufacturer" };

                        newDevice.AddValues(values, deviceObj.Object);

                        newDevice.AddChildItem(new DriveEntry("Capacity",
                            ulong.Parse(deviceObj.Object.GetProperty("Capacity").ToString()),
                            newItem));

                        newDevice.AddChildItem(new DriveEntry("Speed",
                            uint.Parse(deviceObj.Object.GetProperty("Speed").ToString()),
                            newItem));

                        valueMap = ValueMap.Create(
                          deviceObj.Object.GetProperty("MemoryType").ToString(),
                          ValueList.MemoryType);

                        newDevice.AddChildItem(new DriveEntry("MemoryType", valueMap, newItem));

                        valueMap = ValueMap.Create(
                         deviceObj.Object.GetProperty("FormFactor").ToString(),
                         ValueList.MemoryFormFactor);

                        newDevice.AddChildItem(new DriveEntry("FormFactor", valueMap, newItem));

                        newDevices.AddChildItem(newDevice);
                    }

                    writer.Add(newDevices);

                }//foreach CIM_Memory
            }

            public override object GetReturnObject()
            {
                return new NameValuePairItem(Name, Value);
            }
        }//end memory class

        //class MediaDevice : DriveContainer
        //{
        //    public MeduaDevice(DriveItem parent)
        //        : base("MeduaDevice", parent)
        //    {
        //        _items = null;
        //        _value = new Container();
        //    }

        //    public override void GetChildItems(ChildWriter writer)
        //    {
        //        InventoryService service = (InventoryService)Parent;

        //        IWsmanEnumeration colObj = service.ExecQuery("SELECT * FROM CIM_MediaAccessDevice");
        //        foreach (IWsmanItem item in colObj)
        //        {
        //            HardwareItem newItem = new HardwareItem(
        //                item.Object.GetProperty("DeviceID").ToString(),
        //                this);

        //            ValueMap valueMap = ValueMap.Create(
        //                   item.Object.GetProperty("MaxMediaSize").ToString(),
        //                   ValueList.MaxMediaSize);

        //            newItem.AddChildItem(new DriveEntry("MaxMediaSize", valueMap, newItem));

                   

        //            writer.Add(newItem);
        //        }
        //        IWsmanEnumeration cimRealizeObj = service.ExecQuery("SELECT * FROM CIM_Realizes");
        //        IManagedInstance packageInstance = null;
        //        foreach (IWsmanItem item in cimRealizeObj)
        //        {
        //            if (item.Object.GetProperty("Dependent").IsA("CIM_Processor"))
        //            {
        //                IManagedInstance cpuObj = item.Object.GetProperty("Dependent").Ref.Get();
        //                IManagedInstance chipObj = item.Object.GetProperty("Antecedent").Ref.Get()
        //        }
                  
        //            cimRealizeObj.AddSelector("Dependent", mediaDevice.Object.ToReference("DeviceID"));

        //    }

        //    public override object GetReturnObject()
        //    {
        //        return new NameValuePairItem(Name, Value);
        //    }


        //}//end ComputerSystem

       
        class Cpu : DriveContainer
        {
            public Cpu(DriveItem parent)
                : base("Cpu", parent)
            {
                _items = null;
                _value = new Container();
            }


            public override void GetChildItems(ChildWriter writer)
            { 

                InventoryService service = (InventoryService)Parent;

                //Read Processor Information 
                IWsmanEnumeration colObj = service.ExecQuery("SELECT * FROM CIM_Realizes");

                foreach (IWsmanItem item in colObj)
                {
                    //GroupComponent
                    //PartComponent
                    if (item.Object.GetProperty("Dependent").IsA("CIM_Processor"))
                    {
                        IManagedInstance cpuObj = item.Object.GetProperty("Dependent").Ref.Get();
                        IManagedInstance chipObj = item.Object.GetProperty("Antecedent").Ref.Get();

                        HardwareItem newItem = new HardwareItem(
                            cpuObj.GetProperty("DeviceID").ToString()
                            , this);

                        string[] cpuValues = { "Role", "Stepping", };
                        newItem.AddValues(cpuValues, chipObj);

                        ValueMap valueMap = ValueMap.Create(
                            cpuObj.GetProperty("Family").ToString(),
                            ValueList.CpuFamily);

                        newItem.AddChildItem(new DriveEntry("Family", valueMap, newItem));


                        newItem.AddChildItem(new DriveEntry("CurrentClockSpeed",
                           uint.Parse(cpuObj.GetProperty("CurrentClockSpeed").ToString()),
                           newItem));

                        newItem.AddChildItem(new DriveEntry("MaxClockSpeed",
                           uint.Parse(cpuObj.GetProperty("MaxClockSpeed").ToString()),
                           newItem));

                        if (!cpuObj.GetProperty("ExternalBusClockSpeed").IsNull)
                        {

                            newItem.AddChildItem(new DriveEntry("ExternalBusClockSpeed",
                              uint.Parse(cpuObj.GetProperty("ExternalBusClockSpeed").ToString()),
                              newItem));
                        }


                        valueMap = ValueMap.Create(
                         cpuObj.GetProperty("CPUStatus").ToString(),
                         ValueList.CpuStatus);

                        newItem.AddChildItem(new DriveEntry("CPUStatus", valueMap, newItem));

                        valueMap = ValueMap.Create(
                         cpuObj.GetProperty("UpgradeMethod").ToString(),
                         ValueList.CpuUpgradeMethod);

                        newItem.AddChildItem(new DriveEntry("UpgradeMethod", valueMap, newItem));

                        string[] chipValues = { "Manufacturer", "Version" };
                        newItem.AddValues(chipValues, chipObj);

                        bool locationFound = false;
                        try
                        {
                            // Select PhysicalLocation from CIM_PhysicalElementLocation WHERE Element= ChipObj
                            IWsmanEnumeration locations = service.ExecQuery("CIM_PhysicalElementLocation"); ;
                            foreach (IWsmanItem location in locations)
                            {
                                IManagedInstance elementObj = location.Object.GetProperty("Element").Ref.Get();
                                if (elementObj.GetProperty("Tag").ToString().Equals(chipObj.GetProperty("Tag").ToString()))
                                {
                                    if (!locationFound)
                                    {
                                        locationFound = true;
                                        IManagedInstance locationObj = location.Object.GetProperty("PhysicalLocation").Ref.Get();
                                        string[] locationValues = { "PhysicalPosition" };
                                        newItem.AddValues(locationValues, locationObj);
                                    }
                                }
                            }
                        }
                        catch (WsmanUnreachableException)
                        {
                        }
                        writer.Add(newItem);
                    } // is Processor
                } // foreach CIM_Realizes
            }

            public override object GetReturnObject()
            {
                return new NameValuePairItem(Name, Value);
            }

         
        }// end CPU class

   
   
      
    } // End InventoryService
} // end Namespace