#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <random>
#include <chrono>

std::vector<double> data;
std::mutex mtx;
std::condition_variable cv;

// データが10個以上あればメインスレッドを起こすという条件を定義
// 判断中にdata.size()が変化する可能性があるので、必ずロック中に呼び出すこと
bool allow_to_main_wakeup() {
    return data.size() >= 10;
}

// 無限にデータを生成し続ける関数
// ただし、10個データが貯まったらメインスレッドで処理する要求を出す
// メインスレッドがデータを移動する間、このスレッドは休止する
void Factory() {

    // 値を生成する関数
    int count = 0;
    auto create_value = [&count]() { return count++; };

    // 無限にデータを生成してdataに追加し続ける
    while (true) {

        bool allow_to_wakeup = false;
        {
            // 仮に、先にメインスレッドでlockした場合、このスレッドはlock(mtx); でブロック中となる
            // メインスレッド側ですぐにcv.wait()で待機開始するため、すぐにこのブロックは解除されることが期待できる
            std::unique_lock<std::mutex> lock(mtx);

            //==================================
            // データ作成処理本体
            data.push_back( create_value() );
            //==================================

            // メインスレッドで処理してよいかを判断。
            // data.size()が別スレッドで変化しないために、ロック中に判断する
            allow_to_wakeup = allow_to_main_wakeup(); 


            // 仮に、先にFactoryでlockした場合、メインスレッドはlock(mtx); でブロック中となっている
            // ここでスコープを抜けてunlockすることでメインスレッドがlockできるようになり、すぐにcv.wait()で待機開始
        }

        // 現在メインスレッドはcv.wait()で待機中となっている。
        // 特定の条件を満たしたら、メインスレッドで処理するためにメインスレッドを起こす処理をする
        if (allow_to_wakeup == true) {

            // notify_oneは同じcv.waitにより待機中のスレッドを一つだけ起こす。
            cv.notify_one();

            // notify_one()はこのスレッドには何もしないのでここはすぐに処理される
            // これ以降の処理はmainスレッドとの並列処理となる

        }

        // あまり速く動いても動作確認がしづらいのでスリープを入れる
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

int main() {

    // Factory関数を別スレッドで実行
    // 以後、別スレッドでデータが自動生成され続ける
    std::thread producer(Factory);

    std::vector<double> tmp;

    // 
    while (true) {

        {
            // ここでロック。ただしFactory関数側とどちらが先にロックするかは不定
            std::unique_lock<std::mutex> lock(mtx);

            // waitすると内部でmtx.unlock()が呼ばれる
            // これによりFactory側でlock(mtx)ができるようになり、データの生成が可能になる
            // 同時に、このスレッドはFactory側でnotify_one()が呼ばれるまでここで待機
            cv.wait(lock, [] { return allow_to_main_wakeup(); });
            // cv.waitのラムダ式はSpurious Wakeup対策。
            // 希にwait()中に何もしていないのにスレッドが起こされることがある
            // そのため、起こされたときに本当に起こされるべきかを関数により確認する        

            // ここから先はcv.notify_one()により起こされてから実行される
            // これ以降の処理はFactory関数との並列処理となる。
            // なおwait()を抜けた時点で、lockは再びlock状態となる

            //==================================
            // 別スレッドで作成されたデータを移動
            tmp = std::move(data);
            //==================================
        }

        std::cout << "Generated numbers: ";
        for (double num : tmp) {
            std::cout << num << " ";
        }
        std::cout << std::endl;
    }



    producer.join();
    return 0;
}

void Test() {
    // #include "skia/include/core/SkSurface.h"

    SkImageInfo imginfo = SkImageInfo::Make(400, 400, kBGRA_8888_SkColorType, kOpaque_SkAlphaType);
    sk_sp<SkSurface> surface = SkSurfaces::Raster(imginfo);
    SkCanvas* canvas = surface->getCanvas();

    // 図形の描画
    SkPaint paint;
    paint.setStyle(SkPaint::kStroke_Style);
    paint.setStrokeWidth(5);
    paint.setColor(SK_ColorBLUE);
    canvas->clear(SK_ColorWHITE);
    canvas->drawCircle(200, 200, 100, paint);


    // PNG出力
    SkPixmap pixmap;
    if (surface->peekPixels(&pixmap)) {
        SkFILEWStream stream("test_sksurface.png");
        SkPngEncoder::Options options;
        options.fZLibLevel = 9;
        SkPngEncoder::Encode(&stream, pixmap, options);
    }

}

#pragma once

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

#include <wx/geometry.h>

#include <cmath>
#include <wx/gdicmn.h>

//! @brief 画像を回転させる
//! @param transform 回転させる画像のアフィン変換行列
//! @param imageCoordPos 回転の中心となる画像座標系の座標
//! @param rad 回転角度（ラジアン）
void RotateAroundPoint(wxAffineMatrix2D& transform, const wxPoint2DDouble& imageCoordPos, const double rad);


//! @brief 画像をクライアント座標系で移動させる
//! @param transform 移動させる画像のアフィン変換行列
//! @param diff 移動量（パネルのクライアント座標系）
void TranslateInScreenSpace(wxAffineMatrix2D& transform, const wxPoint& diff);


//! @brief クライアント座標を元画像の座標系に変換
//! @param clientPos クライアント座標
//! @param transform 画像のアフィン変換行列
//! @return 元画像の座標系の座標
wxPoint2DDouble ClientToImage(const wxPoint& clientPos, const wxAffineMatrix2D& transform);

//! @brief 画像を拡大・縮小する
//! @param transform 拡大・縮小する画像のアフィン変換行列
//! @param scalefactor 拡大・縮小率
//! @param clientpos 拡大・縮小の中心座標（クライアント座標系）
//! @details clientposに表示されているピクセルが移動しないように拡大・縮小する
//! @return なし
void Zoom(wxAffineMatrix2D& transform, double scalefactor, const wxPoint clientpos);

//! @brief ウィンドウサイズの変化から、拡大・縮小率を計算する
//! @param oldSize リサイズ前のウィンドウサイズ
//! @param newSize リサイズ後のウィンドウサイズ
//! @return 拡大・縮小率
double CalcResizeScaleFactor(const wxSize& oldSize, const wxSize& newSize);

//! @brief マウスドラッグによる拡大・縮小率を計算する
//! @param oldpos ドラッグ開始時のマウス座標
//! @param newpos ドラッグ中のマウス座標
//! @return 拡大・縮小率
double CalcDragScaleFactor(const wxAffineMatrix2D& transform, const wxPoint& oldpos, const wxPoint& newpos, const int pixelratio);


//! @brief ウィンドウサイズが変化したときに、現在画面中央に表示されているピクセルが、リサイズ後も中央に表示されるようにする
//! @param oldSize リサイズ前のウィンドウサイズ
//! @param newSize リサイズ後のウィンドウサイズ
//! @return なし
void ResizeKeepCenter(wxAffineMatrix2D& transform, const wxSize& oldSize, const wxSize& newSize);

//! @brief 画像をパネルにフィットさせるためのアフィン変換行列を計算
//! @param transform アフィン変換行列
//! @param imageSize 元画像のサイズ
//! @param panelSize パネルのサイズ
//! @return なし
void FitImage(wxAffineMatrix2D& transform, const wxSize& imageSize, const wxSize& panelSize);

//! @brief 3点の座標から回転角を計算する
//! @param a 1つ目の座標（始点）
//! @param b 2つ目の座標（回転中心）
//! @param c 3つ目の座標（終点）
//! @details cを中心に、aからbへ回転した時の回転角を計算する
//! @return 回転角（ラジアン）
double CalculateAngle(const wxPoint& a, const wxPoint& b, const wxPoint& c);

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

// マウスによる移動量を角度で計算するクラス
class MouseDrag {
    bool _during;    // ドラッグ中かどうか
    wxPoint _center; // 角度計算の中心座標
    wxPoint _from;   // 開始地点のマウス座標
    wxPoint _to;     // 現在のマウス座標
public:
    MouseDrag(const wxPoint center) : _during(false), _center(center) {}
    MouseDrag() : _during(false), _center(0, 0) {}

    //! @brief ドラッグの開始地点
    wxPoint GetFrom()const { return _from; }

    //! @brief ドラッグの現在地点
    wxPoint GetTo()const { return _to; }

    //! @brief ドラッグ開始
    void Start(const wxPoint newPos) {
        _from = newPos;
        _during = true;
    }
    //! @brief ドラッグ終了
    void Stop() { _during = false; }

    //! @brief  現在回転中かどうか
    bool During() { return _during; }

    //! @brief  マウスの移動量を更新
    void Update(const wxPoint& newPos) {_to = newPos;}

    //! @brief マウスの移動量から角度を計算
    double Angle() const{return CalculateAngle(_to, _center, _from);}

    //! @brief マウスの移動量を取得
    wxPoint Difference()const {return _to - _from;}
};

class ImagePanel : public wxPanel {
    enum class DragMode {
        NONE,
        MOVE,
        ROTATE,
        ZOOM
    };
    wxAffineMatrix2D _transform;         //!< アフィン変換行列
    wxAffineMatrix2D _transform_back;    //!< 移動・回転前のアフィン変換行列のバックアップ
    wxSize _winsize_back;                //!< ウィンドウサイズが変更されるたびに更新されるウィンドウサイズのバックアップ
    // ウィンドウサイズの変化に関しては、変更開始イベントを拾えないため、変化するたびに前回からの差分に基づいて計算する

    DragMode _drag_mode;                 //!< ドラッグモード
    MouseDrag _mov_dragging;             //!< マウスドラッグ間の移動量を計算・管理
    std::weak_ptr<wxBitmap> _imageBitmap;//!< 画像データ

public:
    ImagePanel(wxWindow* parent);

    //! @brief イベントのバインド
    void EventBind();

private:

    //! @brief ペイントイベントハンドラ
    void OnPaint(wxPaintEvent& event);
    
    //! @brief イベントハンドラ（移動開始イベントにバインドする用）
    void OnEventMoveStart(wxMouseEvent& event);
    
    //! @brief イベントハンドラ（移動終了イベントにバインドする用）
    void OnEventMoveStop(wxMouseEvent& event);
    
    //! @brief イベントハンドラ（回転開始イベントにバインドする用）
    void OnEventRotateStart(wxMouseEvent& event);

    //! @brief イベントハンドラ（回転終了イベントにバインドする用）
    void OnEventRotateStop(wxMouseEvent& event);
    
    //! @brief イベントハンドラ（ドラッグでスケーリング開始イベントにバインドする用）
    void OnEventScaleStart(wxMouseEvent& event);

    //! @brief イベントハンドラ（ドラッグでスケーリング終了イベントにバインドする用）
    void OnEventScaleStop(wxMouseEvent& event);

    //! @brief マウス移動イベントハンドラ
    void OnMouseMove(wxMouseEvent& event);
    
    //! @brief イベントハンドラ（ホイール回転でスケーリングイベントにバインドする用）
    void OnEventScaleChange(wxMouseEvent& event);

    //! @brief ウィンドウサイズ変更イベントハンドラ
    void OnResize(wxSizeEvent& event);

public:
    //! @brief 表示する画像をセット
    //! @param bitmap 表示する画像データ
    //! return なし
    void SetImage(const std::shared_ptr<wxBitmap>& bitmap);

    //! @brief 画像が画面に収まるように調節する
    void FitImageToPanel();

private:

    //! @brief クライアント領域の中央の座標を取得
    //! @return クライアント領域のサイズの1/2
    wxPoint GetClientCenter();

    //! @brief ドラッグしてズーム処理の開始
    //! @param pos ドラッグ開始時のマウス座標
    //! @return なし
    void ZoomStart(const wxPoint& pos);

    //! @brief ドラッグしてズーム処理の終了
    //! @return なし
    void ZoomStop();

    //! @brief ドラッグ中のズーム処理
    //! @param pos ドラッグ中のマウス座標
    //! @return 画面更新が必要かどうか
    bool ZoomDuring(const wxPoint& pos);

    //! @brief ドラッグして移動処理の開始
    //! @param pos ドラッグ開始時のマウス座標
    //! @return なし
    void MoveStart(const wxPoint& pos);

    //! @brief ドラッグして移動処理の終了
    //! @return なし
    void MoveStop();

    //! @brief ドラッグして移動中の処理
    //! @param pos ドラッグ中のマウス座標
    //! @return 画面更新が必要かどうか
    bool MoveDuring(const wxPoint& pos);

    //! @brief ドラッグして回転処理の開始
    //! @param pos ドラッグ開始時のマウス座標
    //! @return なし
    void RotateStart(const wxPoint& pos);

    //! @brief ドラッグして回転処理の終了
    //! @return なし
    void RotateStop();

    //! @brief ドラッグして回転中の処理
    //! @param pos ドラッグ中のマウス座標
    //! @return 画面更新が必要かどうか
    bool RotateDuring(const wxPoint& pos);

};

#include "ImagePanel.hpp"


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

void RotateAroundPoint(wxAffineMatrix2D& transform, const wxPoint2DDouble& imageCoordPos, const double rad) {
    // 基準点 (px, py) を原点に移動
    transform.Translate(imageCoordPos.m_x, imageCoordPos.m_y);
    // 回転を適用 (角度はラジアン単位)
    transform.Rotate(rad);

    // 元の位置に戻す
    transform.Translate(-imageCoordPos.m_x, -imageCoordPos.m_y);

}

void TranslateInScreenSpace(wxAffineMatrix2D& transform, const wxPoint& diff) {
    // アフィン変換行列の現在の回転・スケーリングを取得
    wxMatrix2D mat2D;
    wxPoint2DDouble translation;
    transform.Get(&mat2D, &translation);

    // 回転を取り除くために逆回転行列を作成
    double rad = std::atan2(mat2D.m_12, mat2D.m_11); // 現在の回転角を計算（ラジアン）
    wxAffineMatrix2D inverseRotation;
    inverseRotation.Rotate(-rad);

    // スケーリング値を計算
    double scaleX = std::sqrt(mat2D.m_11 * mat2D.m_11 + mat2D.m_21 * mat2D.m_21);
    double scaleY = std::sqrt(mat2D.m_12 * mat2D.m_12 + mat2D.m_22 * mat2D.m_22);


    // 移動量 (dx, dy) を回転の影響を受けない座標系に変換
    wxPoint2DDouble adjustedMove = inverseRotation.TransformPoint(wxPoint2DDouble(diff.x, diff.y));

    // 変換行列に移動を適用
    transform.Translate(adjustedMove.m_x / scaleX, adjustedMove.m_y / scaleX);
}

wxPoint2DDouble ClientToImage(const wxPoint& clientPos, const wxAffineMatrix2D& transform) {
    wxAffineMatrix2D inverse = transform;
    inverse.Invert();
    wxPoint2DDouble imagePos = inverse.TransformPoint(wxPoint2DDouble(clientPos));
    return imagePos;
}

void Zoom(wxAffineMatrix2D& transform, double scalefactor, const wxPoint clientpos) {
    // クライアント座標を元画像の座標系に変換
    wxPoint2DDouble imagePos = ClientToImage(clientpos, transform);

    // スケーリングの中心をマウス座標に固定
    transform.Translate(imagePos.m_x, imagePos.m_y);
    transform.Scale(scalefactor, scalefactor);
    transform.Translate(-imagePos.m_x, -imagePos.m_y);

}

double CalcResizeScaleFactor(const wxSize& oldSize, const wxSize& newSize) {
    double diffx = newSize.GetWidth() - oldSize.GetWidth();
    double diffy = newSize.GetHeight() - oldSize.GetHeight();
    double scalex = newSize.GetWidth() / (double)oldSize.GetWidth();
    double scaley = newSize.GetHeight() / (double)oldSize.GetHeight();
    double scalefactor = 1.0;

    if ((int)diffy != 0)
        scalefactor = scaley;


    return scalefactor;
}
double CalcDragScaleFactor(const wxAffineMatrix2D& transform, const wxPoint& oldpos, const wxPoint& newpos, const int pixelratio) {

    // 原点からの距離を計算
    double olddist = std::sqrt(oldpos.x * oldpos.x + oldpos.y * oldpos.y);
    double newdist = std::sqrt(newpos.x * newpos.x + newpos.y * newpos.y);



    double scalefactor = 1.0;
    if (olddist < newdist) {
        // 拡大
        scalefactor = 1.0 + (newdist - olddist) / pixelratio;
    }
    else {
        // 縮小
        scalefactor = 1.0 - (olddist - newdist) / pixelratio;
    }

    return scalefactor;

}

void ResizeKeepCenter(wxAffineMatrix2D& transform, const wxSize& oldSize, const wxSize& newSize) {
    wxPoint oldwndCenter = wxPoint(oldSize.GetWidth() / 2, oldSize.GetHeight() / 2);
    wxPoint newwndCenter = wxPoint(newSize.GetWidth() / 2, newSize.GetHeight() / 2);

    // リサイズ前の画面中央に表示されていた画像の座標を取得
    wxPoint2DDouble oldImageCenter = ClientToImage(oldwndCenter, transform);

    // 画面サイズの変化に応じた新しい中央座標を取得
    wxPoint2DDouble newImageCenter = ClientToImage(newwndCenter, transform);

    // 変位を計算し、元の画像位置を新しい中央に移動
    wxPoint2DDouble shift = oldImageCenter - newImageCenter;
    transform.Translate(-shift.m_x, -shift.m_y);

}

void FitImage(wxAffineMatrix2D& transform, const wxSize& imageSize, const wxSize& panelSize) {
    double scaleX = static_cast<double>(panelSize.GetWidth()) / imageSize.GetWidth();
    double scaleY = static_cast<double>(panelSize.GetHeight()) / imageSize.GetHeight();
    double scale = std::min(scaleX, scaleY);

    // 中心を計算
    wxPoint offset(
        (panelSize.GetWidth() - imageSize.GetWidth() * scale) / 2,
        (panelSize.GetHeight() - imageSize.GetHeight() * scale) / 2);

    // アフィン変換を設定
    transform = wxAffineMatrix2D();
    transform.Translate(offset.x, offset.y);
    transform.Scale(scale, scale);

}

double CalculateAngle(const wxPoint& a, const wxPoint& b, const wxPoint& c) {
    wxRealPoint ab(b.x - a.x, b.y - a.y);
    wxRealPoint cb(b.x - c.x, b.y - c.y);

    // 内積を計算
    double dotProduct = ab.x * cb.x + ab.y * cb.y;

    // ベクトルの大きさを計算
    double magnitudeAB = std::sqrt(ab.x * ab.x + ab.y * ab.y);
    double magnitudeCB = std::sqrt(cb.x * cb.x + cb.y * cb.y);

    // コサイン
    double cosTheta = dotProduct / (magnitudeAB * magnitudeCB);
    cosTheta = std::min(1.0, std::max(-1.0, cosTheta));

    // 角度を計算（ラジアン）
    double angleRad = std::acos(cosTheta);

    // 外積を使って角度の符号を決定
    double cross = (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
    if (cross < 0.0)
        angleRad = -angleRad;


    return angleRad;// angleRad * 180.0 / M_PI;
}