use std::ffi::CString;
use std::ffi::OsString;
use std::mem::zeroed;
use winapi::ctypes::c_void;
use winapi::shared::minwindef::LPVOID;
use winapi::shared::ntdef::NULL;
use winapi::shared::windef::HBITMAP;
use winapi::shared::windef::HDC;
use winapi::shared::windef::HGDIOBJ;
use winapi::shared::windef::RECT;
use winapi::um::fileapi::CreateFileA;
use winapi::um::fileapi::WriteFile;
use winapi::um::fileapi::CREATE_ALWAYS;
use winapi::um::winbase::GlobalAlloc;
use winapi::um::winbase::GlobalLock;
use winapi::um::winbase::GHND;
use winapi::um::wingdi::BitBlt;
use winapi::um::wingdi::CreateCompatibleBitmap;
use winapi::um::wingdi::CreateCompatibleDC;
use winapi::um::wingdi::DeleteDC;
use winapi::um::wingdi::DeleteObject;
use winapi::um::wingdi::GetDIBits;
use winapi::um::wingdi::GetObjectA;
use winapi::um::wingdi::GetObjectW;
use winapi::um::wingdi::SelectObject;
use winapi::um::wingdi::SetStretchBltMode;
use winapi::um::wingdi::StretchBlt;
use winapi::um::wingdi::BITMAP;
use winapi::um::wingdi::BITMAPFILEHEADER;
use winapi::um::wingdi::BITMAPINFO;
use winapi::um::wingdi::BITMAPINFOHEADER;
use winapi::um::wingdi::BI_RGB;
use winapi::um::wingdi::DIB_RGB_COLORS;
use winapi::um::wingdi::HALFTONE;
use winapi::um::wingdi::SRCCOPY;
use winapi::um::winnt::FILE_ATTRIBUTE_NORMAL;
use winapi::um::winnt::GENERIC_WRITE;
use winapi::um::winnt::HANDLE;
use winapi::um::winuser::GetClientRect;
use winapi::um::winuser::GetDC;
use winapi::um::winuser::GetDesktopWindow;
use winapi::um::winuser::GetSystemMetrics;
use winapi::um::winuser::SM_CXSCREEN;
use winapi::um::winuser::SM_CYSCREEN;

fn main() {
    const width: i32 = 1000;
    const height: i32 = 500;
    unsafe {
        let desktopHandle = GetDesktopWindow();
        let mut windowDC = GetDC(desktopHandle);
        let mut screenDC = GetDC(std::ptr::null_mut());
        let blitDC = CreateCompatibleDC(windowDC);
        let mut rect = zeroed::<RECT>();
        GetClientRect(desktopHandle, &mut rect);
        SetStretchBltMode(windowDC, HALFTONE);
        if StretchBlt(
            windowDC,
            0,
            0,
            rect.right,
            rect.bottom,
            screenDC,
            0,
            0,
            GetSystemMetrics(SM_CXSCREEN),
            GetSystemMetrics(SM_CYSCREEN),
            SRCCOPY,
        ) == 0
        {
            println!("Error StretchBlt");
        };

        let outputBitmap =
            CreateCompatibleBitmap(windowDC, rect.right - rect.left, rect.bottom - rect.top);
        SelectObject(blitDC, outputBitmap as HGDIOBJ);

        if BitBlt(
            blitDC,
            0,
            0,
            rect.right - rect.left,
            rect.bottom - rect.top,
            windowDC,
            0,
            0,
            SRCCOPY,
        ) == 0
        {
            println!("There was an error BitBlt")
        }
        let mut bmpScreen: BITMAP = std::mem::uninitialized();
        GetObjectW(
            outputBitmap as HANDLE,
            std::mem::size_of::<BITMAP>() as i32,
            &mut bmpScreen as *mut BITMAP as LPVOID,
        );
        let mut bi = zeroed::<BITMAPINFO>();
        let mut bmfHeader = zeroed::<BITMAPFILEHEADER>();
        bi.bmiHeader.biSize = std::mem::size_of::<BITMAPINFOHEADER>() as u32;
        bi.bmiHeader.biWidth = bmpScreen.bmWidth;
        bi.bmiHeader.biHeight = bmpScreen.bmHeight;
        bi.bmiHeader.biPlanes = 1;
        bi.bmiHeader.biBitCount = 32;
        bi.bmiHeader.biCompression = BI_RGB;
        bi.bmiHeader.biSizeImage = 0;
        bi.bmiHeader.biXPelsPerMeter = 0;
        bi.bmiHeader.biYPelsPerMeter = 0;
        bi.bmiHeader.biClrUsed = 0;
        bi.bmiHeader.biClrImportant = 0;

        let bitCount = bi.bmiHeader.biBitCount as i32;
        let dwBmpSize = ((bmpScreen.bmWidth * bitCount + 31) / 32) * 4 * bmpScreen.bmHeight;
        let t = dwBmpSize as usize;

        let hDIB = GlobalAlloc(GHND, t);
        let lpbitmap = GlobalLock(hDIB);

        if GetDIBits(
            blitDC,
            outputBitmap,
            0,
            bmpScreen.bmHeight as u32,
            lpbitmap,
            &mut bi,
            DIB_RGB_COLORS,
        ) == 0
        {
            println!("ERror: GetDIBIts")
        };
        let filename = CString::new("test.bmp").expect("CString failed");
        let file = CreateFileA(
            filename.as_ptr(),
            GENERIC_WRITE,
            0,
            std::ptr::null_mut(),
            CREATE_ALWAYS,
            FILE_ATTRIBUTE_NORMAL,
            std::ptr::null_mut(),
        );
        let sizeofBMF = std::mem::size_of::<BITMAPFILEHEADER>() as u32;
        let sizeofBIH = std::mem::size_of::<BITMAPINFOHEADER>() as u32;
        let dwSizeOfDIB = dwBmpSize as u32 + sizeofBMF + sizeofBIH;

        bmfHeader.bfOffBits = sizeofBIH + sizeofBMF;
        bmfHeader.bfSize = dwSizeOfDIB;
        bmfHeader.bfType = 0x4D42;

        WriteFile(
            file,
            &mut bmfHeader as *mut BITMAPFILEHEADER as LPVOID,
            sizeofBMF,
            std::ptr::null_mut(),
            std::ptr::null_mut(),
        );
        WriteFile(
            file,
            &mut bi.bmiHeader as *mut BITMAPINFOHEADER as LPVOID,
            sizeofBIH,
            std::ptr::null_mut(),
            std::ptr::null_mut(),
        );
        WriteFile(
            file,
            lpbitmap,
            dwBmpSize as u32,
            std::ptr::null_mut(),
            std::ptr::null_mut(),
        );

        // if ok != 0 {
        //     let filename = CString::new("test.bmp").expect("CString failed");
        //     CreateFileA(
        //         filename.as_ptr(),
        //         GENERIC_WRITE,
        //         0,
        //         std::ptr::null_mut(),
        //         CREATE_ALWAYS,
        //         FILE_ATTRIBUTE_NORMAL,
        //         std::ptr::null_mut(),
        //     );
        // }

        DeleteObject(outputBitmap as HGDIOBJ);
        DeleteDC(blitDC);
    }
}