Yoda/src/app/browser/main.cpp

#include "main.hpp"
#include "main/tab.hpp"

using namespace app::browser;

Main::Main(
    sqlite3 * database,
    const Glib::RefPtr<Gio::SimpleAction> & ACTION__CLOSE,
    const Glib::RefPtr<Gio::SimpleAction> & ACTION__CLOSE_ALL,
    const Glib::RefPtr<Gio::SimpleAction> & ACTION__HISTORY_BACK,
    const Glib::RefPtr<Gio::SimpleAction> & ACTION__HISTORY_FORWARD,
    const Glib::RefPtr<Gio::SimpleAction> & ACTION__RELOAD,
    const Glib::RefPtr<Gio::SimpleAction> & ACTION__UPDATE
) {
    // Init database
    Database::Session::init(
        this->database = database
    );

    // Init widget
    set_orientation(
        Gtk::Orientation::VERTICAL
    );

    set_homogeneous(
        HOMOGENEOUS
    );

    // Init components
    mainTab = Gtk::make_managed<main::Tab>(
        database,
        ACTION__CLOSE,
        ACTION__CLOSE_ALL,
        ACTION__HISTORY_BACK,
        ACTION__HISTORY_FORWARD,
        ACTION__RELOAD,
        ACTION__UPDATE
    );

        append(
            * mainTab
        );
}

// Actions

/// Session
int Main::session_restore(
    const sqlite3_int64 & APP_BROWSER__SESSION__ID
) {
    sqlite3_stmt* statement; // @TODO move to the Database model namespace

    const int PREPARE_STATUS = sqlite3_prepare_v3(
        database,
        Glib::ustring::sprintf(
            R"SQL(
                SELECT * FROM `app_browser_main__session`
                        WHERE `app_browser__session__id` = %d
            )SQL",
            APP_BROWSER__SESSION__ID
        ).c_str(),
        -1,
        SQLITE_PREPARE_NORMALIZE,
        &statement,
        nullptr
    );

    if (PREPARE_STATUS == SQLITE_OK)
    {
        while (sqlite3_step(statement) == SQLITE_ROW)
        {
            mainTab->session_restore(
                sqlite3_column_int64(
                    statement,
                    Database::Session::ID
                )
            );
        }
    }

    return sqlite3_finalize(
        statement
    );
};

void Main::session_save(
    const sqlite3_int64 & APP_BROWSER__SESSION__ID
) {
    char * error; // @TODO

    // Delete previous data
    Database::Session::clean(
        database,
        APP_BROWSER__SESSION__ID
    ); // @TODO run on background

    // Create new session
    const sqlite3_int64 APP_BROWSER_MAIN__SESSION__ID = Database::Session::add(
        database,
        APP_BROWSER__SESSION__ID
    );

    // Delegate save actions to children components
    mainTab->session_save(
        APP_BROWSER_MAIN__SESSION__ID
    );
};

/// Tab actions
void Main::tab_append()
{
    mainTab->append(
        true
    );
};

void Main::tab_pin()
{
    mainTab->pin(
        mainTab->get_current_page()
    );
};

void Main::tab_close()
{
    mainTab->close(
        mainTab->get_current_page()
    );
};

void Main::tab_close_left()
{
    mainTab->close_left();
};

void Main::tab_close_right()
{
    mainTab->close_right();
};

void Main::tab_close_all()
{
    mainTab->close_all();
};

//// Tab page navigation
void Main::tab_page_navigation_reload() {
    mainTab->page_navigation_reload(
        mainTab->get_current_page(), // @TODO
        true
    );
};

///// Tab page navigation history
void Main::tab_page_navigation_history_back()
{
    mainTab->page_navigation_history_back(
        mainTab->get_current_page() // @TODO
    );
};

void Main::tab_page_navigation_history_forward()
{
    mainTab->page_navigation_history_forward(
        mainTab->get_current_page() // @TODO
    );
};

/// Other
void Main::update()
{
    mainTab->update(
        mainTab->get_current_page()
    );
};

// Getters
Glib::ustring Main::get_tab_page_title()
{
    return mainTab->get_page_title(
        mainTab->get_current_page()
    );
};

Glib::ustring Main::get_tab_page_description()
{
    return mainTab->get_page_description(
        mainTab->get_current_page()
    );
};


// Database
int Main::Database::Session::init(
    sqlite3 * database
) {
    char * error;

    return sqlite3_exec(
        database,
        R"SQL(
            CREATE TABLE IF NOT EXISTS `app_browser_main__session`
            (
                `id`   INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `app_browser__session__id` INTEGER NOT NULL,
                `time` INTEGER NOT NULL DEFAULT CURRENT_TIMESTAMP
            )
        )SQL",
        nullptr,
        nullptr,
        &error
    );
}

int Main::Database::Session::clean(
    sqlite3 * database,
    const sqlite3_int64 & APP_BROWSER__SESSION__ID
) {
    char * error; // @TODO
    sqlite3_stmt * statement;

    const int PREPARE_STATUS = sqlite3_prepare_v3(
        database,
        Glib::ustring::sprintf(
            R"SQL(
                SELECT * FROM `app_browser_main__session`
                        WHERE `app_browser__session__id` = %d
            )SQL",
            APP_BROWSER__SESSION__ID
        ).c_str(),
        -1,
        SQLITE_PREPARE_NORMALIZE,
        &statement,
        nullptr
    );

    if (PREPARE_STATUS == SQLITE_OK)
    {
        while (sqlite3_step(statement) == SQLITE_ROW)
        {
            const sqlite3_int64 APP_BROWSER_MAIN__SESSION__ID = sqlite3_column_int64(
                statement,
                Database::Session::ID
            );

            // Delete record
            const int EXEC_STATUS = sqlite3_exec(
                database,
                Glib::ustring::sprintf(
                    R"SQL(
                        DELETE FROM `app_browser_main__session` WHERE `id` = %d
                    )SQL",
                    APP_BROWSER_MAIN__SESSION__ID
                ).c_str(),
                nullptr,
                nullptr,
                &error
            );

            // Delegate children dependencies cleanup
            if (EXEC_STATUS == SQLITE_OK)
            {
                main::Tab::Database::Session::clean(
                    database,
                    APP_BROWSER_MAIN__SESSION__ID
                );
            }
        }
    }

    return sqlite3_finalize(
        statement
    );
}

sqlite3_int64 Main::Database::Session::add(
    sqlite3 * database,
    const sqlite3_int64 & APP_BROWSER__SESSION__ID
) {
    char * error; // @TODO

    sqlite3_exec(
        database,
        Glib::ustring::sprintf(
            R"SQL(
                INSERT INTO `app_browser_main__session` (
                    `app_browser__session__id`
                ) VALUES (
                    %d
                )
            )SQL",
            APP_BROWSER__SESSION__ID
        ).c_str(),
        nullptr,
        nullptr,
        &error
    );

    return sqlite3_last_insert_rowid(
        database
    );
}