wWxApp.cpp

#include <map>
#include "wWxApp.h"

#include "wWxFrame.h"
#include "weatherProvider.h"
#include "weather.h"
#include "dot.h"
#include "sqlite3.h"
wxIMPLEMENT_APP(wWxApp);
WwxFrame* framePtr = NULL;
using Record = std::vector<std::string>;
using Records = std::vector<Record>;
wxBEGIN_EVENT_TABLE(WwxButton, wxButton)

    EVT_BUTTON(wxID_ANY, WwxFrame::OnButton)

wxEND_EVENT_TABLE()

bool wWxApp::OnInit()
{
    if (!wxApp::OnInit())
        return false;

    // Create the main frame window
    WwxFrame* frame =new WwxFrame("weather now", 50, 50);
    framePtr = frame;

    wxMenu* file_menu = new wxMenu;
    file_menu->Append(TEXT_QUIT, "E&xit\tAlt-X", "Quit");

    wxMenuBar* menu_bar = new wxMenuBar(wxMB_DOCKABLE);
    menu_bar->Append(file_menu, "&File");

    frame->SetMenuBar(menu_bar);

    frame->Show(true);

    tempFetcherThread_ = std::thread{ &wWxApp::InitializeWeatherFetcher, this };
    tempUpdaterThread_ = std::thread{ &wWxApp::UpdateTempFromWeather, this };
    // report success
    return true;
}

int select_callback(void* p_data, int num_fields, char** p_fields, char** p_col_names)
{
    Records* records = static_cast<Records*>(p_data);
    try {
        records->emplace_back(p_fields, p_fields + num_fields);
    }
    catch (...) {
        // abort select on failure, don't let exception propogate thru sqlite3 call-stack
        return 1;
    }
    return 0;
}

Records select_stmt(const std::string& stmt, sqlite3* db)
{
    Records records;
    char* errmsg;
    int ret = sqlite3_exec(db, stmt.c_str(), select_callback, &records, &errmsg);
    if (ret != SQLITE_OK) {
        std::cerr << "Error in select statement " << stmt << "[" << errmsg << "]\n";
    }
    else {
        std::cerr << records.size() << " records returned.\n";
    }

    return records;
}

void wWxApp::InitializeWeatherFetcher()
{
    std::this_thread::sleep_for(std::chrono::seconds(2));
    auto& weather = Weather::getInstance();
    WeatherProvider provider;
    sqlite3* db = NULL;
    int exit = -1;
    exit = sqlite3_open("weather.db", &db);

    // Test if there was an error
    if (exit) {

        std::cout << "DB Open Error: " << sqlite3_errmsg(db) << std::endl;

    }
    else {

        std::cout << "Opened Database Successfully!" << std::endl;
    }

    std::string query = "SELECT * FROM provider;";
    Records records = select_stmt(query, db);
    if (records.size() > 0)
    {
        const auto& providerRow = records[0];
        provider.name_ = providerRow[1];
        provider.apiKey_ = providerRow[3];
        provider.url_ = providerRow[2];
    }
    records.clear();

    query = "SELECT * FROM setting WHERE name = 'interval';";
    records = select_stmt(query, db);
    if (records.size() > 0)
    {

        uint32_t interval = std::stoul(records[0][2]);
         weather.SetConfig(interval, provider);
    }

    //Get Interval from database and pass it on.
   
    sqlite3_close(db);
}

void wWxApp::UpdateTempFromWeather()
{
    auto& weather = Weather::getInstance();
    while (!stop_)
    {
        //std::cout << "Fetching data: " << weather.GetWeather().temp_ << std::endl;
        if (weather.CheckIfFetcherIsRunning())
        {
            if (panelPtr != NULL)
            {
                std::string msg = std::to_string(weather.GetWeather().temp_);
                msg += Dot::GetInstance().GetDot();
                panelPtr->data_->SetValue(msg.c_str());

            }
        }
        else
        {
            if (panelPtr != NULL)
            {
                std::string msg{ "Waiting " };
                msg += Dot::GetInstance().GetDot();
                panelPtr->data_->SetValue(msg.c_str());
            }
        }
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }
}

wWxApp::~wWxApp()
{
    stop_ = true;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    tempFetcherThread_.join();
    tempUpdaterThread_.join();
}