/*
 *     .============.
 *    //  M A K E  / \
 *   //  C++ DEV  /   \
 *  //  E A S Y  /  \/ \
 * ++ ----------.  \/\  .
 *  \\     \     \ /\  /
 *   \\     \     \   /
 *    \\     \     \ /
 *     -============'
 *
 * Copyright (c) 2018 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include <gtest/gtest.h>
#include <thread>

#include "loop.h"
#include "timer_event.h"

#include <tbox/base/log.h>
#include <tbox/base/log_output.h>
#include <tbox/base/scope_exit.hpp>

namespace tbox {
namespace event {

using namespace std;
using namespace std::chrono;

TEST(CommonLoop, isRunning)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        TimerEvent *sp_timer = sp_loop->newTimerEvent();
        SetScopeExitAction([sp_loop, sp_timer]{ delete sp_timer; delete sp_loop; });

        sp_timer->initialize(chrono::milliseconds(10), Event::Mode::kOneshot);
        bool is_run = false;
        sp_timer->setCallback(
            [sp_loop, &is_run] {
                is_run = true;
                EXPECT_TRUE(sp_loop->isRunning());
            }
        );
        sp_timer->enable();

        EXPECT_FALSE(sp_loop->isRunning());

        sp_loop->exitLoop(chrono::milliseconds(50));
        sp_loop->runLoop();

        EXPECT_TRUE(is_run);
        EXPECT_FALSE(sp_loop->isRunning());
    }
}

TEST(CommonLoop, isInLoopThread)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        TimerEvent *sp_timer = sp_loop->newTimerEvent();
        SetScopeExitAction([sp_loop, sp_timer]{ delete sp_timer; delete sp_loop; });

        sp_timer->initialize(chrono::milliseconds(10), Event::Mode::kOneshot);
        bool is_timer_run = false;
        sp_timer->setCallback(
            [sp_loop, &is_timer_run] {
                is_timer_run = true;
                EXPECT_TRUE(sp_loop->isInLoopThread());
            }
        );
        sp_timer->enable();

        bool is_thread_run = false;
        auto t = thread(
            [sp_loop, &is_thread_run] {
                is_thread_run = true;
                this_thread::sleep_for(chrono::milliseconds(10));
                EXPECT_FALSE(sp_loop->isInLoopThread());
            }
        );

        sp_loop->exitLoop(chrono::milliseconds(50));
        sp_loop->runLoop();

        EXPECT_TRUE(is_timer_run);
        EXPECT_TRUE(is_thread_run);

        t.join();
    }
}

TEST(CommonLoop, runNextInsideLoop)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        TimerEvent *sp_timer1 = sp_loop->newTimerEvent();
        TimerEvent *sp_timer2 = sp_loop->newTimerEvent();
        SetScopeExitAction(
            [sp_loop, sp_timer1, sp_timer2]{
                delete sp_timer2;
                delete sp_timer1;
                delete sp_loop;
            }
        );

        sp_timer1->initialize(chrono::milliseconds(10), Event::Mode::kOneshot);
        bool is_run = false;
        sp_timer1->setCallback(
            [&] {
                sp_loop->runNext([&] { is_run = true; });
            }
        );
        sp_timer1->enable();

        sp_timer2->initialize(chrono::milliseconds(20), Event::Mode::kOneshot);
        bool is_timer_run = false;
        sp_timer2->setCallback(
            [&] {
                is_timer_run = true;
                EXPECT_TRUE(is_run);
                sp_loop->exitLoop();
            }
        );
        sp_timer2->enable();

        sp_loop->runLoop();

        EXPECT_TRUE(is_timer_run);
    }
}

//! runNext() 支持在Loop之前操作
TEST(CommonLoop, runNextBeforeLoop)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        TimerEvent *sp_timer = sp_loop->newTimerEvent();
        SetScopeExitAction([sp_loop, sp_timer]{ delete sp_timer; delete sp_loop; });

        bool is_run_next_run = false;
        sp_loop->runNext([&] { is_run_next_run = true; });

        bool is_timer_run = false;
        sp_timer->initialize(chrono::milliseconds(10), Event::Mode::kOneshot);
        sp_timer->setCallback(
            [&] {
                is_timer_run = true;
                EXPECT_TRUE(is_run_next_run);
                sp_loop->exitLoop();
            }
        );
        sp_timer->enable();

        sp_loop->runLoop();

        EXPECT_TRUE(is_timer_run);
    }
}

TEST(CommonLoop, runNextForever)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        int count = 0;
        std::function<void()> func;
        func = [&] {
            ++count;
            sp_loop->runNext(func);
        };

        sp_loop->runNext(func);

        sp_loop->exitLoop(chrono::milliseconds(1));
        sp_loop->runLoop();

        EXPECT_GT(count, 1);
        cout << "count:" << count << endl;

        delete sp_loop;
    }
}

TEST(CommonLoop, runInLoopInsideLoop)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        TimerEvent *sp_timer1 = sp_loop->newTimerEvent();
        TimerEvent *sp_timer2 = sp_loop->newTimerEvent();
        SetScopeExitAction(
            [sp_loop, sp_timer1, sp_timer2]{
                delete sp_timer2;
                delete sp_timer1;
                delete sp_loop;
            }
        );

        sp_timer1->initialize(chrono::milliseconds(10), Event::Mode::kOneshot);
        bool is_run = false;
        sp_timer1->setCallback(
            [&] {
                sp_loop->runInLoop([&] { is_run = true; });
            }
        );
        sp_timer1->enable();

        sp_timer2->initialize(chrono::milliseconds(20), Event::Mode::kOneshot);
        bool is_timer_run = false;
        sp_timer2->setCallback(
            [&] {
                is_timer_run = true;
                EXPECT_TRUE(is_run);
                sp_loop->exitLoop();
            }
        );
        sp_timer2->enable();

        sp_loop->runLoop();

        EXPECT_TRUE(is_timer_run);
    }
}

TEST(CommonLoop, runInLoopBeforeLoop)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        TimerEvent *sp_timer = sp_loop->newTimerEvent();
        SetScopeExitAction([sp_loop, sp_timer]{ delete sp_timer; delete sp_loop; });

        bool is_run = false;
        sp_loop->runInLoop([&] { is_run = true; });

        sp_timer->initialize(chrono::milliseconds(10), Event::Mode::kOneshot);
        bool is_timer_run = false;
        sp_timer->setCallback(
            [&] {
                is_timer_run = true;
                EXPECT_TRUE(is_run);
            }
        );
        sp_timer->enable();

        sp_loop->exitLoop(chrono::milliseconds(20));
        sp_loop->runLoop();

        EXPECT_TRUE(is_timer_run);
    }
}

TEST(CommonLoop, runInLoopCrossThread)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        TimerEvent *sp_timer = sp_loop->newTimerEvent();
        SetScopeExitAction([sp_loop, sp_timer]{ delete sp_timer; delete sp_loop; });

        bool is_thread_run = false;
        bool is_run = false;
        auto t = thread(
            [&] {
                is_thread_run = true;
                this_thread::sleep_for(chrono::milliseconds(10));
                sp_loop->runInLoop([&]{ is_run = true; });
            }
        );

        sp_timer->initialize(chrono::milliseconds(20), Event::Mode::kOneshot);
        bool is_timer_run = false;
        sp_timer->setCallback(
            [&] {
                is_timer_run = true;
                EXPECT_TRUE(is_run);
            }
        );
        sp_timer->enable();

        sp_loop->exitLoop(chrono::milliseconds(50));
        sp_loop->runLoop();

        EXPECT_TRUE(is_timer_run);
        EXPECT_TRUE(is_thread_run);

        t.join();
    }
}

TEST(CommonLoop, runInsideLoop)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        TimerEvent *sp_timer1 = sp_loop->newTimerEvent();
        TimerEvent *sp_timer2 = sp_loop->newTimerEvent();
        SetScopeExitAction(
            [sp_loop, sp_timer1, sp_timer2]{
                delete sp_timer2;
                delete sp_timer1;
                delete sp_loop;
            }
        );

        sp_timer1->initialize(chrono::milliseconds(10), Event::Mode::kOneshot);
        bool is_run = false;
        sp_timer1->setCallback(
            [&] {
                sp_loop->run([&] { is_run = true; });
            }
        );
        sp_timer1->enable();

        sp_timer2->initialize(chrono::milliseconds(20), Event::Mode::kOneshot);
        bool is_timer_run = false;
        sp_timer2->setCallback(
            [&] {
                is_timer_run = true;
                EXPECT_TRUE(is_run);
                sp_loop->exitLoop();
            }
        );
        sp_timer2->enable();

        sp_loop->runLoop();

        EXPECT_TRUE(is_timer_run);
    }
}

TEST(CommonLoop, runBeforeLoop)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        TimerEvent *sp_timer = sp_loop->newTimerEvent();
        SetScopeExitAction([sp_loop, sp_timer]{ delete sp_timer; delete sp_loop; });

        bool is_run = false;
        sp_loop->run([&] { is_run = true; });

        sp_timer->initialize(chrono::milliseconds(10), Event::Mode::kOneshot);
        bool is_timer_run = false;
        sp_timer->setCallback(
            [&] {
                is_timer_run = true;
                EXPECT_TRUE(is_run);
            }
        );
        sp_timer->enable();

        sp_loop->exitLoop(chrono::milliseconds(20));
        sp_loop->runLoop();

        EXPECT_TRUE(is_timer_run);
    }
}

TEST(CommonLoop, runCrossThread)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        TimerEvent *sp_timer = sp_loop->newTimerEvent();
        SetScopeExitAction([sp_loop, sp_timer]{ delete sp_timer; delete sp_loop; });

        bool is_thread_run = false;
        bool is_run = false;
        auto t = thread(
            [&] {
                is_thread_run = true;
                this_thread::sleep_for(chrono::milliseconds(10));
                sp_loop->run([&]{ is_run = true; });
            }
        );

        sp_timer->initialize(chrono::milliseconds(40), Event::Mode::kOneshot);
        bool is_timer_run = false;
        sp_timer->setCallback(
            [&] {
                is_timer_run = true;
                EXPECT_TRUE(is_run);
            }
        );
        sp_timer->enable();

        sp_loop->exitLoop(chrono::milliseconds(50));
        sp_loop->runLoop();

        EXPECT_TRUE(is_timer_run);
        EXPECT_TRUE(is_thread_run);

        t.join();
    }
}

TEST(CommonLoop, runForever)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        int count = 0;
        std::function<void()> func;
        func = [&] {
            ++count;
            sp_loop->run(func);
        };

        sp_loop->run(func);

        sp_loop->exitLoop(chrono::milliseconds(1));
        sp_loop->runLoop();

        EXPECT_GT(count, 1);
        cout << "count:" << count << endl;
        delete sp_loop;
    }
}

TEST(CommonLoop, cleanupDeferedTask)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        TimerEvent *sp_timer1 = sp_loop->newTimerEvent();
        SetScopeExitAction(
            [&]{
                delete sp_timer1;
                delete sp_loop;
            }
        );

        sp_timer1->initialize(chrono::milliseconds(10), Event::Mode::kOneshot);
        bool is_run_1 = false;
        bool is_run_2 = false;
        bool is_run_3 = false;
        sp_timer1->setCallback(
            [&] {
                sp_loop->runInLoop([&] { is_run_1 = true; });
                sp_loop->runNext([&] { is_run_2 = true; });
                sp_loop->run([&] { is_run_3 = true; });
                sp_loop->exitLoop();
            }
        );
        sp_timer1->enable();

        sp_loop->runLoop();

        EXPECT_TRUE(is_run_1);
        EXPECT_TRUE(is_run_2);
        EXPECT_TRUE(is_run_3);
    }
}

TEST(CommonLoop, cleanupDeferedTask1)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);
        SetScopeExitAction( [&]{ delete sp_loop; });

        std::function<void()> func;
        func = [&] {
            cout << '.' << flush;
            sp_loop->runInLoop(func);
        };
        sp_loop->run(func);

        sp_loop->exitLoop(chrono::milliseconds(10));
        sp_loop->runLoop();
    }
}

TEST(CommonLoop, RunInLoopBenchmark)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        int counter = 0;
        function<void()> func = [&] {
            sp_loop->runInLoop(func);
            ++counter;
        };
        sp_loop->runInLoop(func);

        sp_loop->exitLoop(chrono::seconds(10));
        sp_loop->runLoop();

        delete sp_loop;
        cout << "10s count: " << counter << endl;
    }
}

TEST(CommonLoop, RunNextBenchmark)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        int counter = 0;
        function<void()> func = [&] {
            sp_loop->runNext(func);
            ++counter;
        };
        sp_loop->runNext(func);

        sp_loop->exitLoop(chrono::seconds(10));
        sp_loop->runLoop();

        delete sp_loop;
        cout << "10s count: " << counter << endl;
    }
}

TEST(CommonLoop, RunBenchmark)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        int counter = 0;
        function<void()> func = [&] {
            sp_loop->run(func);
            ++counter;
        };
        sp_loop->run(func);

        sp_loop->exitLoop(chrono::seconds(10));
        sp_loop->runLoop();

        delete sp_loop;
        cout << "10s count: " << counter << endl;
    }
}

//! 测试取消runNext()委托的任务
TEST(CommonLoop, CancelRunNext)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        int counter = 0;

        auto run_id = sp_loop->runNext([&] { ++counter; });
        EXPECT_TRUE(sp_loop->cancel(run_id));

        sp_loop->exitLoop(chrono::milliseconds(10));
        sp_loop->runLoop();

        delete sp_loop;

        EXPECT_EQ(counter, 0);
    }
}

//! 测试取消runInLoop()委托的任务
TEST(CommonLoop, CancelRunInLoop)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        int counter = 0;

        auto run_id = sp_loop->runInLoop([&] { ++counter; });
        EXPECT_TRUE(sp_loop->cancel(run_id));

        sp_loop->exitLoop(chrono::milliseconds(10));
        sp_loop->runLoop();

        delete sp_loop;

        EXPECT_EQ(counter, 0);
    }
}

//! 测试同时取消runNext()与runInLoop()委托的任务
TEST(CommonLoop, CancelRunNextAndRunInLoop)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        int counter = 0;

        auto run_id_1 = sp_loop->runNext([&] { ++counter; });
        auto run_id_2 = sp_loop->runInLoop([&] { ++counter; });

        EXPECT_TRUE(sp_loop->cancel(run_id_1));
        EXPECT_TRUE(sp_loop->cancel(run_id_2));

        sp_loop->exitLoop(chrono::milliseconds(10));
        sp_loop->runLoop();

        delete sp_loop;

        EXPECT_EQ(counter, 0);
    }
}

//! 测试在在runNext()中同时取消另一个runNext()委托的任务
TEST(CommonLoop, CancelRunNextInRunNext)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        bool is_cancel = false;
        int counter = 0;

        Loop::RunId run_id;
        sp_loop->runNext([&] {
            EXPECT_TRUE(sp_loop->cancel(run_id));
            is_cancel = true;
        });

        run_id = sp_loop->runNext([&] { ++counter; });

        sp_loop->exitLoop(chrono::milliseconds(10));
        sp_loop->runLoop();

        delete sp_loop;

        EXPECT_TRUE(is_cancel);
        EXPECT_EQ(counter, 0);
    }
}

//! 测试在在runInLoop()中同时取消另一个runInLoop()委托的任务
TEST(CommonLoop, CancelRunInLoopInRunInLoop)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        bool is_cancel = false;
        int counter = 0;

        Loop::RunId run_id;
        sp_loop->runInLoop([&] {
            EXPECT_TRUE(sp_loop->cancel(run_id));
            is_cancel = true;
        });

        run_id = sp_loop->runInLoop([&] { ++counter; });

        sp_loop->exitLoop(chrono::milliseconds(10));
        sp_loop->runLoop();

        delete sp_loop;

        EXPECT_TRUE(is_cancel);
        EXPECT_EQ(counter, 0);
    }
}

TEST(CommonLoop, CancelNotExistRun)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        EXPECT_FALSE(sp_loop->cancel(100));

        delete sp_loop;
    }
}

TEST(CommonLoop, ExitLoopMultiTimes)
{
    auto engines = Loop::Engines();
    for (auto e : engines) {
        cout << "engine: " << e << endl;
        Loop *sp_loop = event::Loop::New(e);

        sp_loop->runInLoop([sp_loop] { sp_loop->exitLoop(); });
        sp_loop->exitLoop(chrono::seconds(10));
        sp_loop->runLoop();

        delete sp_loop;
    }
}

}
}