/* (C) 2003 XDA Developers  itsme@xs4all.nl
 *
 * $Header$
 */
#include  <windows.h>
#include  <Pwinuser.h>
#include "debug.h"
#include <string>
#include <winioctl.h>
#include <Storemgr.h>
#include <Diskio.h>
#include "stringutils.h"
#include "vectorutils.h"

bool g_bVerbose= false;

std::string GetStorageDeviceClassString(DWORD dwClass)
{
    switch(dwClass)
    {
case STORAGE_DEVICE_CLASS_BLOCK:        return "STORAGE_DEVICE_CLASS_BLOCK";    
case STORAGE_DEVICE_CLASS_MULTIMEDIA:   return "STORAGE_DEVICE_CLASS_MULTIMEDIA";
default:
    return stringformat("DeviceClass_%x", dwClass);
    }
}
std::string GetStorageDeviceTypeString(DWORD dwType)
{
    std::string str;
    if (dwType&STORAGE_DEVICE_TYPE_PCIIDE         ) str += " PCIIDE";
    if (dwType&STORAGE_DEVICE_TYPE_FLASH          ) str += " FLASH";
    if (dwType&STORAGE_DEVICE_TYPE_ATA            ) str += " ATA";
    if (dwType&STORAGE_DEVICE_TYPE_ATAPI          ) str += " ATAPI";
    if (dwType&STORAGE_DEVICE_TYPE_PCCARD         ) str += " PCCARD";
    if (dwType&STORAGE_DEVICE_TYPE_CFCARD         ) str += " CFCARD";
    if (dwType&STORAGE_DEVICE_TYPE_SRAM           ) str += " SRAM";
    if (dwType&STORAGE_DEVICE_TYPE_DVD            ) str += " DVD";
    if (dwType&STORAGE_DEVICE_TYPE_CDROM          ) str += " CDROM";
    if (dwType&STORAGE_DEVICE_TYPE_USB            ) str += " USB";
    if (dwType&STORAGE_DEVICE_TYPE_1394           ) str += " 1394";
    if (dwType&STORAGE_DEVICE_TYPE_DOC            ) str += " DOC";
    if (dwType&STORAGE_DEVICE_TYPE_UNKNOWN        ) str += " UNKNOWN";
    if (dwType&STORAGE_DEVICE_TYPE_REMOVABLE_DRIVE) str += " REMOVABLE_DRIVE";
    if (dwType&STORAGE_DEVICE_TYPE_REMOVABLE_MEDIA) str += " REMOVABLE_MEDIA";
    DWORD dwLeftover= dwType&~(STORAGE_DEVICE_TYPE_PCIIDE|STORAGE_DEVICE_TYPE_FLASH|STORAGE_DEVICE_TYPE_ATA|STORAGE_DEVICE_TYPE_ATAPI|STORAGE_DEVICE_TYPE_PCCARD|STORAGE_DEVICE_TYPE_CFCARD|STORAGE_DEVICE_TYPE_SRAM|STORAGE_DEVICE_TYPE_DVD|STORAGE_DEVICE_TYPE_CDROM|STORAGE_DEVICE_TYPE_USB|STORAGE_DEVICE_TYPE_1394|STORAGE_DEVICE_TYPE_DOC|STORAGE_DEVICE_TYPE_UNKNOWN|STORAGE_DEVICE_TYPE_REMOVABLE_DRIVE|STORAGE_DEVICE_TYPE_REMOVABLE_MEDIA);
    if (dwLeftover)
        str += stringformat(" DEVTYPE_%x", dwLeftover);
    return str;
}
std::string GetStorageDeviceFlagsString(DWORD dwFlags)
{
    std::string str;
    if (dwFlags&STORAGE_DEVICE_FLAG_READWRITE  ) str += " READWRITE";
    if (dwFlags&STORAGE_DEVICE_FLAG_READONLY   ) str += " READONLY";
    if (dwFlags&STORAGE_DEVICE_FLAG_TRANSACTED ) str += " TRANSACTED";
    if (dwFlags&STORAGE_DEVICE_FLAG_MEDIASENSE ) str += " MEDIASENSE";
    DWORD dwLeftover= dwFlags&~(STORAGE_DEVICE_FLAG_READWRITE|STORAGE_DEVICE_FLAG_READONLY|STORAGE_DEVICE_FLAG_TRANSACTED|STORAGE_DEVICE_FLAG_MEDIASENSE);
    if (dwLeftover)
        str += stringformat(" DEVFLAG_%x", dwLeftover);
    return str;
}

bool dumpDeviceInfo(HANDLE hDsk)
{
    STORAGEDEVICEINFO di;
    di.cbSize= sizeof(STORAGEDEVICEINFO);
    DWORD nReturned;
    if (!DeviceIoControl(hDsk, IOCTL_DISK_DEVICE_INFO, &di, sizeof(di), NULL, 0, &nReturned, NULL)) {
        if (g_bVerbose)
            error("IOCTL_DISK_DEVICE_INFO");
        return false;
    }
    debug("deviceinfo: size=%d profilename=%ls  class=%hs type=%hs flags=%hs\n",
            di.cbSize, di.szProfile, 
            GetStorageDeviceClassString(di.dwDeviceClass).c_str(),
            GetStorageDeviceTypeString(di.dwDeviceType).c_str(), 
            GetStorageDeviceFlagsString(di.dwDeviceFlags).c_str());

    return true;
}
std::string GetStorageIdFlagsString(DWORD dwFlags)
{
    std::string str;
    //if (dwFlags&MANUFACTURERID_INVALID) str += " nomfn";
    //if (dwFlags&SERIALNUM_INVALID) str += " nosn";
    //DWORD dwLeftover= dwFlags&~(MANUFACTURERID_INVALID|SERIALNUM_INVALID);
    //if (dwLeftover)
    str += stringformat(" stgidflags_%x", dwFlags);

    return str;
}
bool dumpStorageId(HANDLE hDsk)
{
    ByteVector buf; buf.resize(sizeof(STORAGE_IDENTIFICATION)+256);
    STORAGE_IDENTIFICATION *si= (STORAGE_IDENTIFICATION *)vectorptr(buf);
    si->dwSize= buf.size();
    DWORD nReturned;
    if (!DeviceIoControl(hDsk, IOCTL_DISK_GET_STORAGEID, NULL, 0, vectorptr(buf), buf.size(), &nReturned, NULL)) {
        if (g_bVerbose)
            error("IOCTL_DISK_GET_STORAGEID");
        return false;
    }
    debug("storageid  size=%d flags=%hs  mfn=%d(%hs)  serial=%d(%hs)\n",
            si->dwSize, GetStorageIdFlagsString(si->dwFlags).c_str(),
            si->dwManufactureIDOffset, &buf[si->dwManufactureIDOffset],
            si->dwSerialNumOffset, &buf[si->dwSerialNumOffset]);

    return true;
}
std::string GetDiskInfoFlagsString(DWORD dwFlags)
{
    std::string str;
    if (dwFlags&DISK_INFO_FLAG_MBR           ) str += " MBR";
    if (dwFlags&DISK_INFO_FLAG_CHS_UNCERTAIN ) str += " CHS_UNCERTAIN";
    if (dwFlags&DISK_INFO_FLAG_UNFORMATTED   ) str += " UNFORMATTED";
    if (dwFlags&DISK_INFO_FLAG_PAGEABLE      ) str += " PAGEABLE";

    DWORD dwLeftover= dwFlags&~(DISK_INFO_FLAG_MBR|DISK_INFO_FLAG_CHS_UNCERTAIN|DISK_INFO_FLAG_UNFORMATTED|DISK_INFO_FLAG_PAGEABLE);
    if (dwLeftover)
        str += stringformat(" DISKINFO_%x", dwLeftover);
    return str;
}

bool dumpDiskInfo(HANDLE hDsk)
{
    DISK_INFO di;
    int cnt=1;
    DWORD nReturned;
    if (!DeviceIoControl(hDsk, IOCTL_DISK_GETINFO, NULL, 0, &di, sizeof(di), &nReturned, NULL)
            && cnt++
        &&!DeviceIoControl(hDsk, IOCTL_DISK_GETINFO, &di, sizeof(di), NULL, 0, &nReturned, NULL)
            && cnt++
        &&!DeviceIoControl(hDsk, DISK_IOCTL_GETINFO, NULL, 0, &di, sizeof(di), &nReturned, NULL)
            && cnt++
        &&!DeviceIoControl(hDsk, DISK_IOCTL_GETINFO, &di, sizeof(di), NULL, 0, &nReturned, NULL)
            ) {
        if (g_bVerbose)
            error("IOCTL_DISK_GETINFO");
        return false;
    }
    debug("diskinfo(%d): %d sectors, %d b/s, %d cyl, %d head/cyl, %d sect/head, flags=%hs\n", cnt,
            di.di_total_sectors, di.di_bytes_per_sect, di.di_cylinders, di.di_heads, di.di_sectors, GetDiskInfoFlagsString(di.di_flags).c_str());

    return true;
}
bool dumpDiskName(HANDLE hDsk)
{
    WCHAR name[MAX_PATH];
    DWORD nReturned;
    if (!DeviceIoControl(hDsk, IOCTL_DISK_GETNAME, NULL, 0, name, sizeof(name), &nReturned, NULL)) {
        if (g_bVerbose)
            error("IOCTL_DISK_GETNAME");
        return false;
    }
    
    debug("diskname: %ls\n", name);
    return true;
}
bool testdisk(const std::string& name)
{
    debug("testing %hs\n", name.c_str());
    HANDLE hDsk= CreateFile( ToWString(name).c_str(), GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
    if (hDsk==NULL || hDsk==INVALID_HANDLE_VALUE) {
        if (g_bVerbose)
            error("open disk %hs", name.c_str());
        return false;
    }

    dumpDeviceInfo(hDsk);
    dumpStorageId(hDsk);
    dumpDiskInfo(hDsk);
    dumpDiskName(hDsk);

    CloseHandle(hDsk);

    debug("\n\n");
    return true;
}
int WINAPI WinMain( HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPTSTR    lpCmdLine,
                   int       nCmdShow)
{
    DebugSetLogfile("tstdsk.log");

    for (int i=0 ; i<16 ; i++)
        testdisk(stringformat("DSK%d:", i));

    testdisk("\\Vol:");
    testdisk("\\Storage\\Vol:");
    testdisk("\\Storage Card\\Vol:");
    testdisk("\\Extended_ROM\\Vol:");

    return 0;
}