#pragma warning(disable:4996)

#include <windows.h>
#include <imm.h>
#pragma comment(lib, "imm32.lib")

#include <string>

// https://learn.microsoft.com/ja-jp/windows/win32/intl/ime-composition-string-values

// 変換中の文字列 GCS_COMPSTR
void test_GCS_COMPSTR(HIMC hIMC, HDC hdc) {

    DWORD inputBytes = ImmGetCompositionStringW(hIMC, GCS_COMPSTR, NULL, 0);
    if (inputBytes) {

        size_t U16Count = inputBytes / sizeof(wchar_t) + 1;// wchar_tでの、NULLを含んだ文字数
        wchar_t* buffer = new wchar_t[U16Count];

        // 確定した文字列を取得
        ImmGetCompositionStringW(hIMC, GCS_COMPSTR, buffer, inputBytes);
        buffer[U16Count - 1] = L'\0';

        // 確定した文字列を描画
        int inx = 0;
        int iny = 0;
        TextOutW(hdc, inx, iny, buffer, wcslen(buffer));

        delete[] buffer;

    }

}

// 変換中の文字列の属性情報 GCS_COMPATTR
void test_GCS_COMPATTR(HIMC hIMC, HDC hdc) {
    DWORD attr = ImmGetCompositionString(hIMC, GCS_COMPATTR, NULL, 0);

    BYTE* buffer = new BYTE[attr];// 変換中の文字数と同じ個数の要素を確保

    ImmGetCompositionString(hIMC, GCS_COMPATTR, buffer, attr);// 変換中の各文字ごとに状態情報が格納される

    char str[256] = {};

    for (size_t i = 0; i < 256; i++)
        str[i] = ' ';
    str[255] = '\0';
    TextOutA(hdc, 0, 30, str, strlen(str));


    size_t i;
    for (i = 0; i < attr; i++) {
        switch (buffer[i])
        {
        case ATTR_INPUT:
            str[i] = 'I';
            break;
        case ATTR_TARGET_CONVERTED:
            str[i] = 'T';
            break;
        case ATTR_CONVERTED:
            str[i] = 'C';
            break;
        case ATTR_FIXEDCONVERTED:
            str[i] = 'F';
            break;
        case ATTR_TARGET_NOTCONVERTED:
            str[i] = 'N';
            break;
        case ATTR_INPUT_ERROR:
            str[i] = 'E';
            break;
        }
	}
    str[i] = '*';
    TextOutA(hdc, 0, 30, str, strlen(str));


    delete[] buffer;
}

// 変換中の文字列内のカーソル位置  
void test_GCS_CURSORPOS(HIMC hIMC, HDC hdc) {
    LONG cursorPos = ImmGetCompositionString(hIMC, GCS_CURSORPOS, NULL, 0);

    char str[256] = {};
    sprintf(str, "cursorPos:%d", cursorPos);

    TextOutA(hdc, 0, 50, str, strlen(str));

}

// 変換開始位置 GCS_DELTASTART
void test_GCS_DELTASTART(HIMC hIMC, HDC hdc) {
    LONG deltaStart = ImmGetCompositionString(hIMC, GCS_DELTASTART, NULL, 0);

    char str[256] = {};
    sprintf(str, "deltaStart:%d", deltaStart);

    TextOutA(hdc, 0, 90, str, strlen(str));

}

// GCS_RESULTSTR
void test_GCS_RESULTSTR(HIMC hIMC,HDC hdc) {
    // GCS_RESULTSTR ... IMEの入力が確定されたフラグ

    // 確定した文字列のバイト数を取得(NULLは含まない)
    DWORD inputBytes = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
    if (inputBytes) {

        size_t U16Count = inputBytes / sizeof(wchar_t) + 1;// wchar_tでの、NULLを含んだ文字数
        wchar_t* buffer = new wchar_t[U16Count];

        // 確定した文字列を取得
        ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, buffer, inputBytes);
        buffer[U16Count - 1] = L'\0';

        // 確定した文字列を描画
        int inx = 100;
        int iny = 100;
        TextOutW(hdc, inx, iny, buffer, wcslen(buffer));

        delete[] buffer;
    }
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {

    HIMC hIMC;

    int inx = 100;
    int iny = 100;
    switch (message) {
    case WM_CREATE:

        // IMEを使用可能にする
        ImmAssociateContext(hWnd, ImmCreateContext());


        break;


    case WM_IME_STARTCOMPOSITION:

        OutputDebugString(L"IME 入力開始\n");

        hIMC = ImmGetContext(hWnd);  // IMEコンテキストを取得
        if (hIMC)
        {
            //　IMEのウィンドウ位置を設定
            COMPOSITIONFORM cf2;
            cf2.dwStyle = CFS_POINT;
            cf2.ptCurrentPos.x = inx;
            cf2.ptCurrentPos.y = iny;
            ImmSetCompositionWindow(hIMC, &cf2); // IMEのウィンドウ位置を設定
            ImmReleaseContext(hWnd, hIMC);
        }
        break;

    case WM_IME_COMPOSITION:

        // IMEの入力中の処理

        hIMC = ImmGetContext(hWnd);
        if (hIMC) {
            HDC hdc = GetDC(hWnd);
            if (lParam & GCS_RESULTSTR) {
                test_GCS_RESULTSTR(hIMC,hdc);
            }
            if (lParam & GCS_COMPSTR) {
                test_GCS_COMPSTR(hIMC, hdc);
            }
            if (lParam & GCS_COMPATTR) {
                test_GCS_COMPATTR(hIMC, hdc);
            }
            if (lParam & GCS_CURSORPOS)
            {
                test_GCS_CURSORPOS(hIMC, hdc);
            }
            if (lParam & GCS_DELTASTART)
            {
                test_GCS_DELTASTART(hIMC, hdc);
            }
            ReleaseDC(hWnd, hdc);
            ImmReleaseContext(hWnd, hIMC);
        }
        break;

    case WM_IME_ENDCOMPOSITION:
        OutputDebugString(L"IME 入力終了\n");
        break;

    case WM_DESTROY:
        PostQuitMessage(0);
        break;

    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return DefWindowProc(hWnd, message, wParam, lParam);;
}

#include <windows.h>
#include <imm.h>
#pragma comment(lib, "imm32.lib")



LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {

    HIMC hIMC;

    int inx = 100;
    int iny = 100;
    switch (message) {
    case WM_CREATE:

        // IMEを使用可能にする
        ImmAssociateContext(hWnd, ImmCreateContext());

        break;

    case WM_IME_STARTCOMPOSITION:

        // IMEでの入力が開始される
        OutputDebugString(L"IME 入力開始\n");

        hIMC = ImmGetContext(hWnd);  // IMEコンテキストを取得
        if (hIMC)
        {
            //　IMEのウィンドウ位置を設定
            COMPOSITIONFORM cf2;
            cf2.dwStyle = CFS_POINT;
            cf2.ptCurrentPos.x = inx;
            cf2.ptCurrentPos.y = iny;
            ImmSetCompositionWindow(hIMC, &cf2); // IMEのウィンドウ位置を設定
            ImmReleaseContext(hWnd, hIMC);
        }
        break;

    case WM_IME_COMPOSITION:

        // IMEの入力中の処理

        hIMC = ImmGetContext(hWnd);
        if (hIMC) {
            if (lParam & GCS_RESULTSTR) {
                // GCS_RESULTSTR ... IMEの入力が確定されたフラグ

                // 確定した文字列のバイト数を取得(NULLは含まない)
                DWORD inputBytes = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
                if (inputBytes) {

                    size_t U16Count = inputBytes / sizeof(wchar_t) + 1;// wchar_tでの、NULLを含んだ文字数
                    wchar_t* buffer = new wchar_t[U16Count];

                    // 確定した文字列を取得
                    ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, buffer, inputBytes);
                    buffer[U16Count - 1] = L'\0';

                    // 確定した文字列を描画
                    HDC hdc = GetDC(hWnd);
                    TextOutW(hdc, inx, iny, buffer, wcslen(buffer));
                    ReleaseDC(hWnd, hdc);

                    delete[] buffer;
                }
            }
            ImmReleaseContext(hWnd, hIMC);
        }
        break;

    case WM_IME_ENDCOMPOSITION:

        OutputDebugString(L"IME 入力終了\n");
        break;

    case WM_DESTROY:
        PostQuitMessage(0);
        break;

    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return DefWindowProc(hWnd, message, wParam, lParam);;
}

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow) {

    WNDCLASS wc;
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = L"SZL-IME-TEST";

    RegisterClass(&wc);

    HWND hWnd = CreateWindowW(L"SZL-IME-TEST", L"title", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 640, 480, NULL, NULL, hInstance, NULL);


    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);

    MSG msg = {};
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return (int)msg.wParam;
}

#ifndef TREE_H
#define TREE_H

#endif //TREE_H

#include <algorithm>
#include <memory>

using namespace std::literals::string_literals;

// ノードを継承したクラスに asString() メンバ関数があるかを判定するコンセプト
template<typename T>
concept HasAsString = requires(T a) {
    { a.asString() } -> std::same_as<std::string>;
};

// ノードの基底クラス
class NodeBase {
protected:
public:
    std::shared_ptr<NodeBase> parent;

    virtual ~NodeBase() = default;
    virtual std::string asString() const = 0;  // 必ず実装させる仮想関数
    virtual std::shared_ptr<NodeBase> getParent() const { return parent; }
    virtual bool isFolder() const = 0;
};

// フォルダクラス
template <HasAsString T>
class Folder : public NodeBase, public std::enable_shared_from_this < Folder<T> > {
    std::vector<std::shared_ptr<NodeBase>> children;  // 子ノードは NodeBase 型を保持

    T value;
    bool isOpen;
public:
    Folder(const T& data) : value(data), isOpen(false) {}

    // 子ノードを追加するメソッド
    void add(const std::shared_ptr<NodeBase>& node) {
        children.push_back(node);
        node->parent = std::dynamic_pointer_cast<NodeBase>(this->shared_from_this());
    }

    const T& getName() const {
        return value;
    }

    std::string asString() const override {
        return value.asString();
    }

    const std::vector<std::shared_ptr<NodeBase>>& getChildren() const {
        return children;
    }
    std::vector<std::shared_ptr<NodeBase>>& getChildren() {
        return children;
    }

    bool getIsOpen() const {
        return isOpen;
    }

    void setIsOpen(bool open) {
        isOpen = open;
    }

    bool isFolder() const override {
		return true;
	}


};

// アイテムクラス
// フォルダに入れるデータを保持するクラス
template <HasAsString T>
class Item : public NodeBase, public std::enable_shared_from_this < Item<T> > {
    T value;
public:
    Item(const T& data) : value(data) {}

    std::string asString() const override {
        return value.asString();
    }

    bool isFolder() const override {
        return false;
    }
};

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

// 全てのノードの数をカウントする関数
template <HasAsString FT>
int getAllNodeCount(const std::shared_ptr<NodeBase>& node) {
    int count = 1;  // 自分自身をカウント

    // フォルダの場合は、子ノードも再帰的にカウント
    if (auto folder = std::dynamic_pointer_cast<Folder<FT>>(node)) {
        for (const auto& child : folder->getChildren()) {
            count += getAllNodeCount<FT>(child);
        }
    }

    return count;
}



// 開いているノードの数をカウントする関数
template <HasAsString FT>
int getOpenNodeCount(const std::shared_ptr<NodeBase>& node) {
    int count = 1;  // 自分自身をカウント

    // フォルダの場合、開いているかどうかを確認
    if (auto folder = std::dynamic_pointer_cast<Folder<FT>>(node)) {
        if (folder->getIsOpen()) {
            // 開いている場合、子ノードも再帰的にカウント
            for (const auto& child : folder->getChildren()) {
                count += getOpenNodeCount<FT>(child);
            }
        }
    }

    return count;
}

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

// 指定した index のノードを取得する関数の補助関数
template <HasAsString FT>
std::shared_ptr<NodeBase> getNodeHelper(const std::shared_ptr<NodeBase>& node, int& currentIndex, int targetIndex, bool open = false) {
    // 現在のノードをカウント
    if (currentIndex == targetIndex) {
        return node;
    }
    currentIndex++;

    // フォルダの場合は、開閉状態を確認し、再帰的に子ノードを探索
    if (auto folder = std::dynamic_pointer_cast<Folder<FT>>(node)) {
        if (open || folder->getIsOpen()) {
            for (const auto& child : folder->getChildren()) {
                auto result = getNodeHelper<FT>(child, currentIndex, targetIndex, open);
                if (result) {
                    return result;
                }
            }
        }
    }

    return nullptr; // 見つからなかった場合
}

// 指定した index のノードを取得する関数
// ここでの index は、開いているノードのみでカウントする
template <HasAsString FT>
std::shared_ptr<NodeBase> getNodeOnlyOpen(const std::shared_ptr<NodeBase>& root, int targetIndex) {
    int currentIndex = 0; // ノードのカウント用
    return getNodeHelper<FT>(root, currentIndex, targetIndex, false);
}


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




// ノードを削除する関数
template <HasAsString FT>
void deleteNode(std::shared_ptr<NodeBase> node) {
    if (auto parent = node->getParent()) {
        if (auto parentFolder = std::dynamic_pointer_cast<Folder<FT>>(parent)) {
            auto& siblings = parentFolder->getChildren();
            siblings.erase(std::remove(siblings.begin(), siblings.end(), node), siblings.end());
        }
    }
}

// 指定したノードの管理情報を取得する関数
// 戻り値 1 親ノード
// 戻り値 2 posで指定したノードを持つ親ノードの、子ノードリストのインデクス
template <HasAsString FT>
std::pair< std::shared_ptr<NodeBase>, int> GetNodeListPos(std::shared_ptr<NodeBase> root, int pos) {

    // posの位置の現在のノードを取得
    auto now_node = getNodeOnlyOpen<FT>(root, pos);

    // now_nodeの親ノードを取得
    auto parent_node = now_node->getParent();

    // now_nodeの親ノードの子ノードリストを取得
    auto parent_folder = std::dynamic_pointer_cast<Folder<FT>>(parent_node);
    auto& siblings = parent_folder->getChildren();

    // now_nodeの親ノードの子ノードリストのインデクスを取得
    auto it = std::find(siblings.begin(), siblings.end(), now_node);
    int index = std::distance(siblings.begin(), it);


    return { parent_node,index };

}

template <HasAsString FT, HasAsString IT>
void addNodeUnder(std::shared_ptr<NodeBase> root, std::shared_ptr<NodeBase> node) {
    // nodeをrootの最後に追加
    auto folder = std::dynamic_pointer_cast<Folder<FT>>(root);
    folder->getChildren().push_back(node);
    node->parent = root;

}

template <HasAsString FT, HasAsString IT>
void addNodeHere(std::shared_ptr<NodeBase> root, std::shared_ptr<NodeBase> node, int pos) {
    // ノードを追加する関数
    // 挿入位置は番号posで指定する
    // 新しく追加したアイテムが必ずpos番目になる
    // 必ず、追加前のposのノードと同じ階層に追加する

    // 番号posは開いているノードのみでカウントする
    // 例えばfolder21がノードを持っていても、folder21は開いていないのでその中のノードはカウントしない
    // 1 - folder1
    // 2   - folder2
    // 3      item21
    // 4      item22
    // 5      + folder21
    // 6   - folder3
    // 7      item31
    // 8      item32
    // 9      item33

    // getNode(folder1,3) == item21
    // この時、
    // 例１ addNode(NewFolder,3) で
    // 2   - folder2
    // 3      + NewFolder
    // 4      item21
    // 5      item22


    auto childinfo = GetNodeListPos<FT>(root, pos);
    std::shared_ptr<NodeBase> childlist = childinfo.first;
    auto index = childinfo.second;

    // nodeをchildlistのindex番に追加
    auto folder = std::dynamic_pointer_cast<Folder<FT>>(childlist);
    folder->getChildren().insert(folder->getChildren().begin() + index, node);
    node->parent = childlist;

}

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



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

struct TreeSliceItem {
    int pos;
    std::shared_ptr<NodeBase> node;
    int hierarchy;
};
template <HasAsString FT>
void GetTreeSliceTraverse(const std::shared_ptr<NodeBase>& node, int hierarchy, int& currentIndex, int from, int to, std::vector<TreeSliceItem>& slice) {
    if (currentIndex >= from && currentIndex <= to) {
        slice.push_back({ currentIndex, node, hierarchy });
    }
    currentIndex++;

    if (auto folder = std::dynamic_pointer_cast<Folder<FT>>(node)) {
        if (folder->getIsOpen()) {
            for (const auto& child : folder->getChildren()) {
                GetTreeSliceTraverse<FT>(child, hierarchy + 1, currentIndex, from, to, slice);
            }
        }
    }
}

// ツリーから一部を取り出す関数
template <HasAsString FT>
std::vector< TreeSliceItem> GetTreeSlice(std::shared_ptr<NodeBase> root, int from, int to) {
    // 例えば、以下の状態の時、
    // 1 - folder1
    // 2   - folder2
    // 3      item21
    // 4      item22
    // 5      + folder21
    // 6   - folder3
    // 7      item31
    // 8      item32
    // 9      item33

    // GetTreeSlice(folder1,3,7) で
    // 3      item21
    // 4      item22
    // 5      + folder21
    // 6   - folder3
    // 7      item31
    // を取得

    std::vector<TreeSliceItem> slice;
    int currentIndex = 0;
    int currentHierarchy = 0;

    GetTreeSliceTraverse<FT>(root, currentHierarchy, currentIndex, from, to, slice);

    return slice;

}