#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;}
};