#include <iostream>

// T型の変数valは、print()と++を持たなければならない
template <class T>
concept CallableFunction = requires (T val) {

    val.print();      // print()関数があることを要求
    val.operator++(); // ++演算子があることを要求
};

// CallableFunctionの制約がついている所で使用できるクラス
class MyValidClass {
    int val;
public:
    MyValidClass() {
        val = 5;
    }

    void print() {// print()関数を定義
		std::cout << "val == " << val << std::endl;
	}

    MyValidClass& operator++() {// ++演算子を要求
        ++val;
		return *this;
	}

};

// CallableFunctionの制約がある場合は指定できない。
// operator++() がない。
class MyInvalid {
    int val;
public:
    MyInvalid() {
        val = 5;
    }

    void print() {
        std::cout << "val == " << val << std::endl;
    }
};

// print()関数と++演算子を持つクラスを引数に取る関数
template <CallableFunction Type>
void func(Type val) {
    val.print();
}

int main()
{
    MyValidClass my;

    func(my);
}

#include <iostream>

#include <algorithm>
#include <vector>

template <class T>
concept Sortable = requires (T& val) {

    // { } 内の式が有効であることを要求する書き方ができる。
    // 例えば、以下は T 型の val はソート可能であることを要求する
    {
        std::sort(val.begin(), val.end())
    };

};

// print()関数と++演算子を持つクラスを引数に取る関数
template <Sortable Type>
void func(Type& val) {

    std::sort(val.begin(), val.end());

}

int main()
{
    std::vector<int> my{ 5,3,8 };

    func(my);


    for (auto& i : my) {
        std::cout << i << std::endl;
    }
}

#include <iostream>

#include <algorithm>
#include <vector>

template <class T>
concept Sizable = requires (T & val) {

    {
        val.size() // size()関数を持つ

    }->std::same_as<size_t>; // size()関数の戻り値はsize_t型
    // std::same_asはconcept。式の戻り値の型を指定する。
};

class MyArray {
    std::vector<int>vec;   
public: 
    void push_back(int i) { vec.push_back(i); }
    int size() { return vec.size(); }
};

// この関数は、戻り値がsize_t型のsize()関数を持つ型しか受け付けない
template <Sizable Type>
void func(Type& val) {

    std::cout<<val.size()<<std::endl;

}

int main()
{
    std::vector<int> my;
    // MyArray my;

    my.push_back(3);
    my.push_back(1);
    my.push_back(8);

    func(my);

}

// プリプロセッサに以下を追加
// __WXMSW__

// static link library の場合、以下は指定しない
// WXUSINGDLL

// サブシステムをWindowsに設定(WinMainで呼び出すので)
// Windows (/SUBSYSTEM:WINDOWS)

#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif

#include <wx/gdicmn.h> // wxPointに必要
#include <wx/frame.h>  // wxFrameに必要

// Win32 API
#pragma comment(lib, "comctl32.lib")
#pragma comment(lib, "rpcrt4.lib")

// wxWidgets
#pragma comment(lib,"wxmsw33u_core.lib")
#pragma comment(lib,"wxbase33u.lib")
#pragma comment(lib,"wxbase33u_net.lib")
#pragma comment(lib,"wxbase33u_xml.lib")
#pragma comment(lib,"wxexpat.lib")
#pragma comment(lib,"wxjpeg.lib")
#pragma comment(lib,"wxlexilla.lib")
#pragma comment(lib,"wxmsw33u_adv.lib")
#pragma comment(lib,"wxmsw33u_aui.lib")
#pragma comment(lib,"wxmsw33u_gl.lib")
#pragma comment(lib,"wxmsw33u_html.lib")
#pragma comment(lib,"wxmsw33u_media.lib")
#pragma comment(lib,"wxmsw33u_propgrid.lib")
#pragma comment(lib,"wxmsw33u_qa.lib")
#pragma comment(lib,"wxmsw33u_ribbon.lib")
#pragma comment(lib,"wxmsw33u_richtext.lib")
#pragma comment(lib,"wxmsw33u_stc.lib")
#pragma comment(lib,"wxmsw33u_webview.lib")
#pragma comment(lib,"wxmsw33u_xrc.lib")
#pragma comment(lib,"wxpng.lib")
#pragma comment(lib,"wxregexu.lib")
#pragma comment(lib,"wxscintilla.lib")
#pragma comment(lib,"wxtiff.lib")
#pragma comment(lib,"wxzlib.lib")


/////////////////////////////////////
/////////////////////////////////////
/////////////////////////////////////

// ウィンドウ作成
class MyFrame : public wxFrame
{
public:
    MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
        : wxFrame(NULL, wxID_ANY, title, pos, size)
    {
    }

private:

    // イベント処理しないときはこれを入れない
    // wxDECLARE_EVENT_TABLE();
};

/////////////////////////////////////
/////////////////////////////////////
/////////////////////////////////////

// wxWidgetsのアプリケーション作成
class MyApp : public wxApp {
public:

    virtual bool OnInit() {
        MyFrame* frame = new MyFrame("Hello World", wxPoint(50, 50), wxSize(450, 340));
        frame->Show(true);
        return true;
    }

};

/////////////////////////////////////
/////////////////////////////////////
/////////////////////////////////////

// WinMainをマクロで定義
wxIMPLEMENT_APP(MyApp);

#pragma warning(disable:4996)

#include <windows.h>

#include <shellapi.h>

static const int TasktrayIconID = 100;
static const int WM_MY_NOTIFYICON = WM_USER + TasktrayIconID;

const int ID_MENU_MSG = 100;
const int ID_MENU_EXIT = 101;

HMENU myCreateMenu();
void intoTasktray(HWND hwnd, const int IconID);
void fromTasktray(HWND hwnd, const int IconID);
void menuPopup(HWND hwnd, HMENU menu);

/////////////////////////////////
/////////////////////////////////
/////////////////////////////////
/////////////////////////////////

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {


  static HMENU hMenu = nullptr;

  switch (msg) {
  case WM_CREATE:
    hMenu = myCreateMenu();//メニュー作成
    break;
  case WM_LBUTTONDOWN://ウィンドウをクリックしたらアイコン表示開始
  {
    intoTasktray(hwnd, TasktrayIconID);
    break;
  }
  case WM_MY_NOTIFYICON:
    if (lp == WM_LBUTTONDOWN && wp == TasktrayIconID) {
      // アイコンを左クリックしたらウィンドウを表示
      fromTasktray(hwnd, TasktrayIconID);
    }
    else if (lp == WM_RBUTTONUP) {
      // アイコンを右クリックしたらポップアップメニューを表示
      menuPopup(hwnd, hMenu);
    }
    break;
  case WM_COMMAND:
    switch (wp)
    {
    case ID_MENU_MSG:  // "Open"がクリックされた場合
      MessageBoxA(hwnd, "MessageBox", "Info", MB_OK);
      break;
    case ID_MENU_EXIT:  // "Exit"がクリックされた場合
      DestroyWindow(hwnd);
      break;
    }
    break;

  case WM_DESTROY:
    DestroyWindow(hwnd);
    PostQuitMessage(0);
    return 0;
  }
  return DefWindowProc(hwnd, msg, wp, lp);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
	PSTR lpCmdLine, int nCmdShow) {
	HWND hwnd;
	MSG msg;
	WNDCLASS winc;

	winc.style = CS_HREDRAW | CS_VREDRAW;
	winc.lpfnWndProc = WndProc;
	winc.cbClsExtra = winc.cbWndExtra = 0;
	winc.hInstance = hInstance;
	winc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	winc.hCursor = LoadCursor(NULL, IDC_ARROW);
	winc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
	winc.lpszMenuName = NULL;
	winc.lpszClassName = TEXT("SZL-WINDOW");

	if (!RegisterClass(&winc)) return -1;

	hwnd = CreateWindow(
		TEXT("SZL-WINDOW"), TEXT("test"),
		WS_OVERLAPPEDWINDOW | WS_VISIBLE,
		CW_USEDEFAULT, CW_USEDEFAULT,
		300, 300,
		NULL, NULL, hInstance, NULL
	);

	if (hwnd == NULL) return -1;

	while (GetMessage(&msg, NULL, 0, 0)) DispatchMessage(&msg);
	return msg.wParam;
}

// メニューの作成
HMENU myCreateMenu() {
  HMENU menu = CreatePopupMenu();
  AppendMenuA(menu, MF_STRING, ID_MENU_MSG, "Open");
  AppendMenuA(menu, MF_STRING, ID_MENU_EXIT, "Exit");

  return menu;
}

// ウィンドウを消し、アイコンをタスクトレイへ格納
void intoTasktray(HWND hwnd, const int IconID) {

  NOTIFYICONDATA nid;
  nid.cbSize = sizeof(nid);
  nid.hWnd = hwnd;
  nid.uID = IconID;//複数のアイコンを表示したときの識別ID。なんでもいい。
  nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
  nid.uCallbackMessage = WM_MY_NOTIFYICON; //WM_USER以降の定数。
  nid.hIcon = (HICON)LoadIcon(NULL, IDI_APPLICATION);
  wcscpy(nid.szTip, L"タスクトレイで表示する文字列");
  int ret = (int)Shell_NotifyIcon(NIM_ADD, &nid);
  ShowWindow(hwnd, SW_HIDE);

}

// タスクトレイからアイコンを削除し、ウィンドウを表示
void fromTasktray(HWND hwnd, const int IconID) {
  ShowWindow(hwnd, SW_SHOW);

  //タスクトレイアイコンを削除
  NOTIFYICONDATA nid;
  nid.cbSize = sizeof(nid);
  nid.hWnd = hwnd;
  nid.uID = IconID;
  nid.uFlags = 0;
  Shell_NotifyIcon(NIM_DELETE, &nid);

}

// ポップアップメニューを表示
void menuPopup(HWND hwnd, HMENU menu) {
  POINT pt;
  GetCursorPos(&pt);
  SetForegroundWindow(hwnd);
  TrackPopupMenu(menu, TPM_RIGHTALIGN, pt.x, pt.y, 0, hwnd, NULL);

}

use windows::Win32::Graphics::Gdi::*;
use windows::core::*;
use windows::Win32::Foundation::*;

// ■ BITMAPINFO         ... windows::Win32::Graphics::Gdi::BITMAPINFO
// ■ BITMAPINFOHEADER   ... windows::Win32::Graphics::Gdi::BITMAPINFOHEADER
// ■ BI_RGB             ... windows::Win32::Graphics::Gdi::BI_RGB
// ■ CreatedHDC         ... windows::Win32::Graphics::Gdi::CreatedHDC
// ■ CreateDCA          ... windows::Win32::Graphics::Gdi::CreateDCA
// ■ CreateCompatibleDC ... windows::Win32::Graphics::Gdi::CreateCompatibleDC
// ■ CreateDIBSection   ... windows::Win32::Graphics::Gdi::CreateDIBSection
// ■ DIB_RGB_COLORS     ... windows::Win32::Graphics::Gdi::DIB_RGB_COLORS
// ■ DeleteDC           ... windows::Win32::Graphics::Gdi::DeleteDC
// ■ HBITMAP            ... windows::Win32::Graphics::Gdi::HBITMAP
// ■ HBITMAP            ... windows::Win32::Graphics::Gdi::HBITMAP
// ■ SelectObject       ... windows::Win32::Graphics::Gdi::SelectObject

// ■ HANDLE             ... windows::Win32::Foundation::HANDLE

// ■ PCSTR              ... windows::core::PCSTR

 pub struct Win32DIBCanvas{
    pub bitmap     :HBITMAP,
    pub bitmapInfo :BITMAPINFO,
    pub ppixel     :*mut std::ffi::c_void,
    pub hMemDC     : CreatedHDC,
}

// ppixel:*mut std::ffi::c_void, があるので、Send,Syncを実装しなければmyDIBをLazy<Mutex<myDIB>>に入れられない
unsafe impl Send for Win32DIBCanvas {}
unsafe impl Sync for Win32DIBCanvas {}

impl Win32DIBCanvas{
    pub fn new()->Win32DIBCanvas{
        Win32DIBCanvas{
            bitmap    :HBITMAP(0),
            bitmapInfo:Default::default(),
            ppixel    :std::ptr::null_mut(),
            hMemDC    :CreatedHDC(0),
        }
    }
    pub fn create(&mut self,width:i32,height:i32){

        

        unsafe{
            let mut hdca = CreateDCA(
                PCSTR::from_raw("DISPLAY\0".as_ptr()),
                None,
                None,
                None
            );

            self.bitmapInfo.bmiHeader.biSize        = std::mem::size_of::<BITMAPINFOHEADER>() as u32;
            self.bitmapInfo.bmiHeader.biWidth       = width;
            self.bitmapInfo.bmiHeader.biHeight      = -height;
            self.bitmapInfo.bmiHeader.biPlanes      = 1;
            self.bitmapInfo.bmiHeader.biBitCount    = 3*8;
            self.bitmapInfo.bmiHeader.biCompression = BI_RGB;

            let hBitmap = CreateDIBSection(
                hdca,
                &self.bitmapInfo,
                DIB_RGB_COLORS,
                &mut self.ppixel,
                HANDLE(0),
                0
            );

            self.hMemDC =  CreateCompatibleDC(hdca);

            if let Ok(hbmp) = hBitmap{
                SelectObject(self.hMemDC,hbmp);
            }

            DeleteDC(hdca);
        }
    }
}

mod winmain;
use winmain::WinMain;


use windows::Win32::Foundation::*;
use windows::Win32::System::LibraryLoader::*;
use windows::Win32::System::Threading::*;

// ■ HINSTANCE        ... windows::Win32::Foundation::HINSTANCE
// ■ GetModuleHandleA ... windows::Win32::System::LibraryLoader::GetModuleHandleA
// ■ STARTUPINFOW     ... windows::Win32::System::Threading::STARTUPINFOW
// ■ GetStartupInfoW  ... windows::Win32::System::Threading::GetStartupInfoW


// Rustのwindows-rsからウィンドウズアプリケーションをビルドする時には、
// WinWain ではなくmainをエントリポイントとする。

fn main()-> windows::core::Result<()>  {

    let hInstance:HINSTANCE;
    unsafe{
        // https://github.com/microsoft/windows-samples-rs/blob/master/create_window/src/main.rs
        hInstance = GetModuleHandleA(None).unwrap();
    }

    // https://doc.rust-jp.rs/book-ja/ch12-01-accepting-command-line-arguments.html
    let args: Vec<String> = std::env::args().collect();


    // https://stackoverflow.com/questions/68322072/how-to-get-args-from-winmain-or-wwinmain-in-rust
    let mut si = STARTUPINFOW {
        cb: std::mem::size_of::<STARTUPINFOW>() as u32,
        ..Default::default()
    };
    unsafe {
        GetStartupInfoW(&mut si) 
    };
    let cmd_show = si.wShowWindow as i32;

    ////////////////////////////////////////////////////////////////////////////////////
    // 自作WinMainを呼び出す

    WinMain(
        hInstance,
        HINSTANCE(0),
        args,
        cmd_show
    );


    Ok(())

}

#[path="./win32dib.rs"]
mod win32dib;
use win32dib::Win32DIBCanvas;


use windows::{
    core::*, 
    Win32::Foundation::*,
    Win32::Graphics::Gdi::*,
    Win32::UI::WindowsAndMessaging::*,
};

use once_cell::sync::Lazy;
use std::sync::Mutex;

// ■ Mutex ... std::sync::Mutex
// ■ Lazy  ... once_cell::sync::Lazy


// DIBを管理する構造体のグローバル変数
static mydib:Lazy<Mutex<Win32DIBCanvas>> = 
        Lazy::new(|| 
            Mutex::new(
                Win32DIBCanvas::new()
            )
        );


// ■ COLORREF            ... windows::Win32::Foundation::COLORREF
// ■ HINSTANCE           ... windows::Win32::Foundation::HINSTANCE
// ■ HWND                ... windows::Win32::Foundation::HWND
// ■ LPARAM              ... windows::Win32::Foundation::LPARAM
// ■ LRESULT             ... windows::Win32::Foundation::LRESULT
// ■ POINT               ... windows::Win32::Foundation::POINT
// ■ RECT                ... windows::Win32::Foundation::RECT        
// ■ WPARAM              ... windows::Win32::Foundation::WPARAM


// ■ BeginPaint          ... windows::Win32::Graphics::Gdi::BeginPaint
// ■ BitBlt              ... windows::Win32::Graphics::Gdi::BitBlt
// ■ CreatePen           ... windows::Win32::Graphics::Gdi::CreatePen
// ■ EndPaint            ... windows::Win32::Graphics::Gdi::EndPaint
// ■ LineTo              ... windows::Win32::Graphics::Gdi::LineTo
// ■ MoveToEx            ... windows::Win32::Graphics::Gdi::MoveToEx
// ■ PS_SOLID            ... windows::Win32::Graphics::Gdi::PS_SOLID
// ■ PAINTSTRUCT         ... windows::Win32::Graphics::Gdi::PAINTSTRUCT
// ■ SelectObject        ... windows::Win32::Graphics::Gdi::SelectObject
// ■ SRCCOPY             ... windows::Win32::Graphics::Gdi::SRCCOPY


// ■ CreateWindowExA     ... windows::Win32::UI::WindowsAndMessaging::CreateWindowExA
// ■ CS_HREDRAW          ... windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW
// ■ CS_VREDRAW          ... windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW
// ■ CW_USEDEFAULT       ... windows::Win32::UI::WindowsAndMessaging::CW_USEDEFAULT
// ■ DefWindowProcA      ... windows::Win32::UI::WindowsAndMessaging::DefWindowProcA
// ■ DispatchMessageA    ... windows::Win32::UI::WindowsAndMessaging::DispatchMessageA
// ■ GetMessageA         ... windows::Win32::UI::WindowsAndMessaging::GetMessageA
// ■ LoadCursorW         ... windows::Win32::UI::WindowsAndMessaging::LoadCursorW
// ■ IDC_ARROW           ... windows::Win32::UI::WindowsAndMessaging::IDC_ARROW
// ■ MSG                 ... windows::Win32::UI::WindowsAndMessaging::MSG
// ■ PostQuitMessage     ... windows::Win32::UI::WindowsAndMessaging::PostQuitMessage
// ■ RegisterClassA      ... windows::Win32::UI::WindowsAndMessaging::RegisterClassA
// ■ WNDCLASSA           ... windows::Win32::UI::WindowsAndMessaging::WNDCLASSA
// ■ WS_OVERLAPPEDWINDOW ... windows::Win32::UI::WindowsAndMessaging::WS_OVERLAPPEDWINDOW
// ■ WS_VISIBLE          ... windows::Win32::UI::WindowsAndMessaging::WS_VISIBLE


// ■ PCSTR               ... windows::core::PCSTR




extern "system" fn wndproc(window: HWND, message: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {


    unsafe {
        
        let rectnullptr: Option<*const RECT> = None;


        match message as u32 {
            WM_CREATE => {

                let refmydib = &mut mydib.lock().unwrap();
                refmydib.create(640,480);

                let hPen =
                CreatePen(
                    PS_SOLID, 
                    1,
                    COLORREF(0x000000FF)
                );  // 赤いペンを作成


                if hPen.is_invalid() == false{
                    // ペンが作成できていたら線を引く

                    let oldPen = SelectObject(
                        refmydib.hMemDC,
                        hPen
                    );

                    // refmydib.hMemDC の 50,50 ～ 100,100 に線を引く
                    MoveToEx(
                        refmydib.hMemDC,
                        50,
                        50,
                        None as Option<*mut POINT>
                    );
                    LineTo(
                        refmydib.hMemDC,
                        100,
                        100
                    );

                    SelectObject(
                        refmydib.hMemDC,
                        oldPen
                    );

                    // ペンを削除
                    DeleteObject(hPen);

                }

                LRESULT(0)
            }
            WM_PAINT => {

                let mut ps = PAINTSTRUCT::default();
                let hdc = BeginPaint(window, &mut ps);
                let refmydib = &mut mydib.lock().unwrap();

                BitBlt(
                    hdc,
                    0,
                    0,
                    640,
                    480,
                    refmydib.hMemDC,
                    0,
                    0,
                    SRCCOPY
                );

                EndPaint(window, &ps);

                LRESULT(0)
            }
            WM_DESTROY => {

                PostQuitMessage(0);

                LRESULT(0)
            }
            _ => DefWindowProcA(window, message, wparam, lparam),
        }
    }
}



/// 自作 WinMain
pub fn WinMain(
        hInstance : HINSTANCE, 
        hPrevInstance : HINSTANCE, 
        lpCmdLine:Vec<String>, 
        nCmdShow:i32
    )->i32{

    unsafe{



        let _hCursor = LoadCursorW(None,IDC_ARROW).unwrap();
        let _hInstance = hInstance;
        let _lpszClassName = PCSTR::from_raw("MY_NEW_WINDOW\0".as_ptr());
        let _style = CS_HREDRAW | CS_VREDRAW;

        // https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/UI/WindowsAndMessaging/struct.WNDCLASSA.html
        let wc=WNDCLASSA{
            hCursor :_hCursor,
            hInstance: _hInstance,
            lpszClassName: _lpszClassName,
            style: _style,
            lpfnWndProc: Some(wndproc),
            ..Default::default()
        };

        let atom = RegisterClassA(&wc);
        debug_assert!(atom != 0);


        let nullptr: Option<*const ::core::ffi::c_void> = None;

        CreateWindowExA(
            Default::default(),
            _lpszClassName,
            PCSTR::from_raw("This is a sample window\0".as_ptr()),
            WS_OVERLAPPEDWINDOW | WS_VISIBLE,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            None,
            None,
            _hInstance,
            nullptr,
        );

        let mut message = MSG::default();

        while GetMessageA(&mut message, HWND(0), 0, 0).into() {
            DispatchMessageA(&mut message);
        }
    }
    return 0;


}