#include <Windows.h>
#include <vector>
#include <iostream>
#include <algorithm>

struct DisplayBpp
{
    DWORD Bpp;
    DWORD Hz;

    explicit DisplayBpp(DWORD bpp, DWORD hz) : Bpp(bpp), Hz(hz) { ; }
};

bool operator ==(const DisplayBpp& lhs, const DisplayBpp& rhs)
{
    return lhs.Bpp == rhs.Bpp && lhs.Hz == rhs.Hz;
}

struct DisplayRes
{
    DWORD Width;
    DWORD Height;

    std::vector<DisplayBpp> Modes;

    explicit DisplayRes(DWORD w, DWORD h) : Width(w), Height(h) { ; }
};

bool operator ==(const DisplayRes& lhs, const DisplayRes& rhs)
{
    return lhs.Height == rhs.Height && lhs.Width == rhs.Width;
}

struct DisplayDev
{
    DISPLAY_DEVICEW Info;
    DisplayRes Current;
    std::vector<DisplayRes> Resolutions;

    explicit DisplayDev(const DISPLAY_DEVICEW& info) : Current(0,0)
    {
        Info = info;
    }

    void update()
    {
        DEVMODEW dm = { 0 };
        dm.dmSize = sizeof(dm);
        if (EnumDisplaySettingsExW(Info.DeviceName, ENUM_CURRENT_SETTINGS, &dm, NULL))
        {
            Current = DisplayRes(dm.dmPelsWidth, dm.dmPelsHeight);
            Current.Modes.push_back(DisplayBpp(dm.dmBitsPerPel, dm.dmDisplayFrequency));
        }
        for (DWORD Num = 0; EnumDisplaySettingsExW(Info.DeviceName, Num, &dm, NULL); ++Num)
        {
            DisplayRes res(dm.dmPelsWidth, dm.dmPelsHeight);
            DisplayBpp bpp(dm.dmBitsPerPel, dm.dmDisplayFrequency);
            std::vector<DisplayRes>::iterator it = std::find(Resolutions.begin(), Resolutions.end(), res);
            if (it == Resolutions.end())
            {
                Resolutions.push_back(res);
                Resolutions.back().Modes.push_back(bpp);
            }
            else
            {
                std::vector<DisplayBpp>& Modes = it->Modes;
                if (std::find(Modes.begin(), Modes.end(), bpp) == Modes.end())
                    Modes.push_back(bpp);
            }
        }
    }
};

std::wostream& operator <<(std::wostream& strm, const DisplayBpp& mode)
{
    strm << mode.Bpp << L"bpp @" << mode.Hz << L"Hz";
    return strm;
}

std::wostream& operator <<(std::wostream& strm, const DisplayRes& res)
{
    strm << res.Width << L"x" << res.Height << L" (";
    bool first = true;
    for (std::vector<DisplayBpp>::const_iterator mode = res.Modes.begin(); mode != res.Modes.end(); ++mode)
    {
        strm << (first ? L"" : L", ") << *mode;
        first = false;
    }
    strm << L")";
    return strm;
}

std::wostream& operator <<(std::wostream& strm, const DisplayDev& dev)
{
    strm << dev.Info.DeviceString << L" (" << dev.Info.DeviceName << L")" << std::endl;
    strm << L"Flags: ";
    bool first = true;
    if (dev.Info.StateFlags & DISPLAY_DEVICE_ACTIVE) { strm << (first ? L"" : L", ") << L"DISPLAY_DEVICE_ACTIVE"; first = false; }
    if (dev.Info.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) { strm << (first ? L"" : L", ") << L"DISPLAY_DEVICE_MIRRORING_DRIVER"; first = false; }
    if (dev.Info.StateFlags & DISPLAY_DEVICE_MODESPRUNED) { strm << (first ? L"" : L", ") << L"DISPLAY_DEVICE_MODESPRUNED"; first = false; }
    if (dev.Info.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) { strm << (first ? L"" : L", ") << L"DISPLAY_DEVICE_PRIMARY_DEVICE"; first = false; }
    if (dev.Info.StateFlags & DISPLAY_DEVICE_REMOVABLE) { strm << (first ? L"" : L", ") << L"DISPLAY_DEVICE_REMOVABLE"; first = false; }
    if (dev.Info.StateFlags & DISPLAY_DEVICE_VGA_COMPATIBLE) { strm << (first ? L"" : L", ") << L"DISPLAY_DEVICE_VGA_COMPATIBLE"; first = false; }
    strm << std::endl;
    if (!dev.Current.Modes.empty())
    {
        strm << L"Current display mode: " << dev.Current << std::endl << std::endl;
    }
    for (std::vector<DisplayRes>::const_iterator res = dev.Resolutions.begin(); res != dev.Resolutions.end(); ++res)
    {
        strm << L" - " << *res << std::endl;
    }
    return strm;
}


int main()
{
	std::vector<DisplayDev> Devices;
    DISPLAY_DEVICEW DisplayDevice = { sizeof(DisplayDevice), NULL };
    for (DWORD Num = 0; EnumDisplayDevicesW(NULL, Num, &DisplayDevice, NULL); ++Num)
    {
        Devices.push_back(DisplayDev(DisplayDevice));
        Devices.back().update();
        std::wcout << Devices.back() << std::endl;
    }
	return 0;
}