/*
 * IPAdaptersInfo.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2009/08/27

#pragma once

//2009/09/03
#include <sol/net/MibTable.h>
#include <sol/Arg.h>
#include <sol/String.h>


namespace SOL {



class IPAdaptersInfo :public MibTable {

/*
typedef struct _IP_ADAPTER_INFO {
  struct _IP_ADAPTER_INFO *Next;
  DWORD                   ComboIndex;
  char                    AdapterName[MAX_ADAPTER_NAME_LENGTH + 4];
  char                    Description[MAX_ADAPTER_DESCRIPTION_LENGTH + 4];
  UINT                    AddressLength;
  BYTE                    Address[MAX_ADAPTER_ADDRESS_LENGTH];
  DWORD                   Index;
  UINT                    Type;
  UINT                    DhcpEnabled;
  PIP_ADDR_STRING         CurrentIpAddress;
  IP_ADDR_STRING          IpAddressList;
  IP_ADDR_STRING          GatewayList;
  IP_ADDR_STRING          DhcpServer;
  BOOL                    HaveWins;
  IP_ADDR_STRING          PrimaryWinsServer;
  IP_ADDR_STRING          SecondaryWinsServer;
  time_t                  LeaseObtained;
  time_t                  LeaseExpires;
}IP_ADAPTER_INFO, *PIP_ADAPTER_INFO;
 */

private:
    IP_ADAPTER_INFO *info;

public:
    /**
     * Constructor
     */
    IPAdaptersInfo()
    :info(NULL) 
    {
    }


public:
    /**
     * Destructor
     */
    ~IPAdaptersInfo()
    {
        clear();
    }

public:
    void clear()
    {
        if (info) {
            delete [] (char*)info;
            info = NULL;
        }
    }


public:
    //2009/09/03
    bool getTable()
    {
        return getInfo();
    }

public:
    /**
     * Get adapters informaiton by call GetAdaptersInfo
     */
    bool getInfo()
    {
        clear();
                
        bool rc = false;
        DWORD dwSize = 0;
        if (GetAdaptersInfo(NULL, &dwSize) == ERROR_BUFFER_OVERFLOW) {
            info = (IP_ADAPTER_INFO *)new char[dwSize];
    
            if (GetAdaptersInfo(info, &dwSize) == NO_ERROR) {
                rc = true;    
            } else {
                clear();
                throw GetLastError();
            }
        }
        return rc;
    }

protected:
    const char* getType(int type)
    {
        static const ArgT<char> types[] = {
            {"OTHER", MIB_IF_TYPE_OTHER},
            {"ETHERNET", MIB_IF_TYPE_ETHERNET},
            {"TOKENRING", MIB_IF_TYPE_TOKENRING},
            {"FDD", MIB_IF_TYPE_FDDI},
            {"PPP", MIB_IF_TYPE_PPP},
            {"LOOPBACK", MIB_IF_TYPE_LOOPBACK},
            {"SLIP", MIB_IF_TYPE_SLIP},
            };
        int count = XtNumber(types);
        const char* name = "";
        for (int i = 0; i<count; i++) {
            if (types[i].value == type) {
                name = types[i].name;
                break;
            }
        }
        return name;
    }



protected:
    // This returns a string of format "00-22-64-70-50-72" for the address
    bool getAdapterAddress(__in const BYTE* bytes, __in size_t length, __out StringT<char>& address)
    {
        bool rc = false;
        if (bytes == NULL) {
            return rc;
        }
        char buffer[128];
        memset(buffer, 0, sizeof(buffer));

        char* ptr = buffer;
        for (int i = 0; i < length; i++) {            
            if (i == (length - 1)) {                        
                sprintf(ptr, "%.2X", (int)bytes[i]);
                ptr = ptr + 2;
            }else {
                sprintf(ptr, "%.2X-", (int)bytes[i]);
                ptr = ptr + 3;
            }
        }
        address = buffer;
        rc = true;
        return rc;
    }


public:
    virtual void display(__in IP_ADAPTER_INFO *adapter)
    {            
        printf("Adapter Name: %s\n", adapter->AdapterName);        
        printf("Adapter Desc: %s\n", adapter->Description);
        
        StringT<char> adapterAddr;
        getAdapterAddress(adapter->Address, adapter->AddressLength, adapterAddr);
        printf("Adapter Addr: %s\n", (const char*)adapterAddr);

        printf("Type : %s\n", getType(adapter->Type));    
        printf("IP Address: %s\n", adapter->IpAddressList.IpAddress.String);        
        printf("IP Mask: %s\n", adapter->IpAddressList.IpMask.String);
        printf("Gateway: %s\n", adapter->GatewayList.IpAddress.String);
        
        if (adapter->DhcpEnabled) {            
            printf("Dhcp Enabled: TRUE\n");
            printf("Dhcp Server: %s\n", adapter->DhcpServer.IpAddress.String);
            
            StringT<char> leaseObtained;
            getLocalTime32(adapter->LeaseObtained, leaseObtained);
            
            StringT<char> leaseExpires;
            getLocalTime32(adapter->LeaseExpires, leaseExpires);

            printf("Lease Obtained: %s", (const char*)leaseObtained);
            printf("Lease Expires: %s", (const char*)leaseExpires);
        } else {        
            printf("DHCP Enabled: FALSE\n");
        }
        
        if (adapter->HaveWins) {
            printf("Have Wins: TRUE\n");
            printf("Primary Wins Server: %s\n", adapter->PrimaryWinsServer.IpAddress.String);    
            printf("Secondary Wins Server: %s\n", adapter->SecondaryWinsServer.IpAddress.String);
        } else {
            printf("Have Wins: FALSE\n");
        }
        printf("\n");
    }

public:
    virtual void display()
    {
        if (getInfo()) {
            if (info) {
                IP_ADAPTER_INFO *ptr = info;
                while (ptr) {
                    display(ptr);
                    ptr = ptr ->Next;
                }
            }
        }        
    }
};


}