#ifndef __DEVICEINFO__H__
#define __DEVICEINFO__H__

// this module gets information from the device which can be used
// to identify the type of device we are running on

#include "stringutils.h"
#include  "cenk.h"
#include  "cever_deps.h"

#define HTC_TYPHOON  0
#define HTC_STARTREK 1
#define HTC_HERALD   2
#define HTC_DIAMOND  3
#define HTC_KAISER   4
#define HTC_VIVA     5
#define HTC_TOPAZ    6
#define HTC_PHOTON   7
#define MOTO_ES400   8


enum paramflags {
    OEMNAMEBIT, PROCNAMEBIT, CORENAMEBIT, ROMVERSIONBIT, PLATFORMTYPEBIT, DEVTYPEBIT
};

static inline bool ReadRegistryString(HKEY hRoot, const std::string& regpath, const std::string& keyname, std::string& value)
{
    DWORD rc=0;
    HKEY hkey= NULL;
    rc= RegOpenKeyEx(hRoot, ToTString(regpath).c_str(), 0, 0, &hkey);
    if (rc)
        return false;
    std::tstring tvalue;
    while (true) {
        tvalue.resize(tvalue.size()+256);
        DWORD maxsize= tvalue.size()*sizeof(tvalue[0]);
        DWORD valtype;
        rc= RegQueryValueEx(hkey, ToTString(keyname).c_str(), NULL, &valtype, (BYTE*)&tvalue[0], &maxsize);
        if (rc==0)
            break;
        if (rc!=ERROR_MORE_DATA) {
            RegCloseKey(hkey);
            return false;
        }
    }
    RegCloseKey(hkey);
    value= ToString(&tvalue[0]);
    return true;
}

class deviceinfo {
private:
    int _flags;
    int _devtype;
    std::string _oemname;
    std::string _procname;
    std::string _corename;
    std::string _romversion;
    std::string _platformtype;

    bool isvalid(int flag) { return _flags & (1<<flag); }
    void setvalid(int flag) { _flags |= (1<<flag); }
public:
    deviceinfo() : _flags(0), _devtype(-1) { }
    std::string getoemname()
    {
        if (isvalid(OEMNAMEBIT))
            return _oemname;
        setvalid(OEMNAMEBIT);
        WCHAR oeminfo[256];
        if (SystemParametersInfo(SPI_GETOEMINFO, 256, oeminfo, 0)) {
            _oemname= ToString(oeminfo);

            debug("devtype: oemname=%s\n", _oemname.c_str());
        }
        return _oemname;
    }
    std::string getcore()
    {
        if (isvalid(CORENAMEBIT))
            return _corename;
        setvalid(CORENAMEBIT);
        setvalid(PROCNAMEBIT);
        getprocessorinfo(_procname, _corename);
        return _corename;
    }
    std::string getproc()
    {
        if (isvalid(PROCNAMEBIT))
            return _procname;
        setvalid(CORENAMEBIT);
        setvalid(PROCNAMEBIT);
        getprocessorinfo(_procname, _corename);
        return _procname;
    }
    std::string romversion()
    {
        if (isvalid(ROMVERSIONBIT))
            return _romversion;
        setvalid(ROMVERSIONBIT);

        ReadRegistryString(HKEY_LOCAL_MACHINE, "Software\\OEM", "ROMVersion", _romversion);

        debug("devtype: romversion=%s\n", _romversion.c_str());

        return _romversion;
    }
    std::string platformtype()
    {
        if (isvalid(PLATFORMTYPEBIT))
            return _platformtype;
        setvalid(PLATFORMTYPEBIT);
        TCHAR reply[256];
        if (!SystemParametersInfo(SPI_GETPLATFORMTYPE, sizeof(reply), reply, 0))
            _platformtype= ToString(reply);

        debug("devtype: platform=%s\n", _platformtype.c_str());
        return _platformtype;
    }
    bool oemnamematches(const std::string& match)
    {
        getoemname();
        return _oemname.find(match)!=_oemname.npos;
    }
    int setdevtype(int type)
    {
        setvalid(DEVTYPEBIT);
        debug("found devtype: %d\n", type);
        return _devtype= type;
    }
    int devtype()
    {
        if (isvalid(DEVTYPEBIT))
            return _devtype;
        getproc();
        platformtype();
        if (oemnamematches("Motorola ES400")) 
            return setdevtype(MOTO_ES400);
        if (oemnamematches("Touch Diamond2")) 
            return setdevtype(HTC_TOPAZ);
        if (oemnamematches("HTC HD mini T5555") || oemnamematches("PB92")) 
            return setdevtype(HTC_PHOTON);
        else if (oemnamematches("Touch Diamond") || oemnamematches("Touch Pro")) {
// HTC Touch Pro T7272, HTC Touch Diamond P3700
            return setdevtype(HTC_DIAMOND);
        }
        else if (oemnamematches("Kaiser")) 
            return setdevtype(HTC_KAISER);
        else if (oemnamematches("HTC")) {
            if (_procname=="OMAP 730") {
                return setdevtype(HTC_TYPHOON);
            }
            else if (_procname=="OMAP850 195MHz") {
                // also S310
                return setdevtype(HTC_STARTREK);
            }
            else if (oemnamematches("HTC Touch Viva T2223")) {
                return setdevtype(HTC_VIVA);
            }
            else {
                debug("unknown device: %s, %s\n", _oemname.c_str(), _procname.c_str());
                return -1;
            }
        }
        else if (oemnamematches("HERA10000") || oemnamematches("HERA*****")) {
            return setdevtype(HTC_HERALD);
        }
        else if (oemnamematches("i-mateSmartflip")) {
            return setdevtype(HTC_STARTREK);
        }
        else {
            debug("unknown device: %s, %s\n", _oemname.c_str(), _procname.c_str());
        }
        return -1;
    }
    bool GetQualcommIpcBuf(DWORD& base, DWORD& size, int& wr, int& rd, int& data)
    {
        switch(devtype())
        {
        case HTC_DIAMOND:
        {
            base= 0x8a00c170;
            size= 0x2014;
            wr= 3*4;
            rd= 4*4;
            data= 5*4;
            return true;
        }
        case HTC_KAISER:
        {
            base= 0x951041f0;
            size= 0x2018;
            wr= 3*4;
            rd= 4*4;
            data= 6*4;
            return true;
        }
        case HTC_TOPAZ:
        {
            base= 0x8a000000;
            size= 0x100000;
            wr= 0;
            rd= 0;
            data= 0;
            return true;
        }
        case HTC_PHOTON:
        {
            base= 0x8cc00000;
            size= 0x100000;
            wr= 0;
            rd= 0;
            data= 0;
            return true;
        }
        case MOTO_ES400:
        {
            base= 0x8cc00000;
            size= 0x100000;
            wr= 0;
            rd= 0;
            data= 0;
            return true;
        }


        default:
            return false;
        }
    }
    bool GetOmapIpcBuf(DWORD& base)
    {
        switch(devtype())
        {
            case HTC_TYPHOON: base= 0x8f180000; break;
            case HTC_STARTREK: base= 0x8a400000; break;
            case HTC_VIVA: /* fall through */
            case HTC_HERALD: base= 0x8a300000; break;
            default: return false;
        }
        return true;
    }
    bool GetKernelLogBuf(DWORD& base, DWORD& size, DWORD& cur)
    {
        switch(devtype())
        {
            //case HTC_TYPHOON: base ?
            case HTC_STARTREK: base=0x8C2F9BA0; size=0x25800; cur=0x8C2DF0A4; break;
            case HTC_VIVA: /* fall through */
            case HTC_HERALD: base=0x8a2c0000; size=0x25bec; cur=0x8A2E5BEC; break;

// these start with struct { ptr, size, size, size, vaddr, size }
            case HTC_DIAMOND:base= PhysToVirt(0x17200018); size= 0xfffe8; cur= PhysToVirt(0x17200000); break;
            case HTC_KAISER: base= PhysToVirt(0x10100018); size= 0xfffe8; cur= PhysToVirt(0x10100000); break;
            case HTC_TOPAZ : base= PhysToVirt(0x16f00018); size= 0xfffe8; cur= PhysToVirt(0x16f00000); break;
            case HTC_PHOTON: base= PhysToVirt(0x0c900018); size= 0xfffe8; cur= PhysToVirt(0x0c900000); break;   // v 8c800000 
            case MOTO_ES400: base= 0x8c900054; size= 0x8000; cur= 0x8c908054; break;
            default:
                   return false;
        }
        return true;
    }
private:
    void getprocessorinfo(std::string& processor, std::string& core)
    {
        PROCESSOR_INFO pi;

        DWORD nReturned;
        if (!KernelIoControl(IOCTL_PROCESSOR_INFORMATION, NULL, 0, &pi, sizeof(pi), &nReturned)) {
            error("IOCTL_PROCESSOR_INFORMATION");
        }
        core= ToString(pi.szProcessCore);
        processor= ToString(pi.szProcessorName);

        debug("devtype: procname=%s  corename=%s\n", processor.c_str(), core.c_str());
    }
};

#endif