#!/usr/bin/env python3

#    Copyright (C) 2012-2016 Christian T. Jacobs.

#    This file is part of PyQSO.

#    PyQSO is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    PyQSO is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with PyQSO.  If not, see <http://www.gnu.org/licenses/>.

from gi.repository import Gtk, Pango, PangoCairo
import logging
import sqlite3 as sqlite
from os.path import basename, getmtime, expanduser
from datetime import datetime, date
import configparser

try:
    from matplotlib.backends.backend_gtk3cairo import FigureCanvasGTK3Cairo as FigureCanvas
    from matplotlib.figure import Figure
    from matplotlib.dates import DateFormatter, MonthLocator
    have_matplotlib = True
except ImportError as e:
    logging.warning(e)
    logging.warning("Could not import matplotlib, so you will not be able to plot annual logbook statistics. Check that all the PyQSO dependencies are satisfied.")
    have_matplotlib = False

from pyqso.adif import *
from pyqso.log import *
from pyqso.log_name_dialog import *
from pyqso.auxiliary_dialogs import *


class Logbook(Gtk.Notebook):

    """ A Logbook object can store multiple Log objects. """

    def __init__(self, parent):
        """ Create a new Logbook object and initialise the list of Logs.

        :arg parent: The parent Gtk window.
        """

        Gtk.Notebook.__init__(self)

        self.parent = parent
        self.connection = None
        self.summary = {}
        self.logs = []
        logging.debug("New Logbook instance created!")
        return

    def new(self, widget=None):
        """ Create a new logbook, and open it. """

        # Get the new file's path from a dialog.
        dialog = Gtk.FileChooserDialog("Create a New SQLite Database File",
                                       self.parent,
                                       Gtk.FileChooserAction.SAVE,
                                      (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
                                       Gtk.STOCK_SAVE, Gtk.ResponseType.OK))
        dialog.set_do_overwrite_confirmation(True)

        response = dialog.run()
        if(response == Gtk.ResponseType.OK):
            path = dialog.get_filename()
        else:
            path = None
        dialog.destroy()

        if(path is None):  # If the Cancel button has been clicked, path will still be None
            logging.debug("No file path specified.")
            return
        else:
            # Clear the contents of the file, in case the file exists already.
            open(path, 'w').close()
            # Open the new logbook, ready for use.
            self.open(path=path)
        return

    def open(self, widget=None, path=None):
        """ Open a logbook, and render all the logs within it.

        :arg str path: An optional argument containing the database file location, if already known. If this is None, a file selection dialog will appear.
        """

        if(path is None):
            # If no path has been provided, get one from a "File Open" dialog.
            dialog = Gtk.FileChooserDialog("Open SQLite Database File",
                                           self.parent,
                                           Gtk.FileChooserAction.OPEN,
                                          (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
                                           Gtk.STOCK_OPEN, Gtk.ResponseType.OK))

            response = dialog.run()
            if(response == Gtk.ResponseType.OK):
                path = dialog.get_filename()
            dialog.destroy()

            if(path is None):  # If the Cancel button has been clicked, path will still be None
                logging.debug("No file path specified.")
                return

        connected = self.db_connect(path)
        if(connected):
            # If the connection setup was successful, then open all the logs in the database

            self.path = path

            logging.debug("Trying to retrieve all the logs in the logbook...")
            self.logs = []  # A fresh stack of Log objects
            try:
                with self.connection:
                    c = self.connection.cursor()
                    c.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT GLOB 'sqlite_*'")
                    for name in c:
                        l = Log(self.connection, name[0])
                        l.populate()
                        self.logs.append(l)
            except (sqlite.Error, IndexError) as e:
                logging.exception(e)
                error(parent=self.parent, message="Oops! Something went wrong when trying to retrieve the logs from the logbook. Perhaps the logbook file is encrypted, corrupted, or in the wrong format?")
                return

            logging.debug("All logs retrieved successfully. Now attempting to render them all in the Gtk.Notebook...")
            # For rendering the logs. One treeview and one treeselection per Log.
            self.treeview = []
            self.treeselection = []
            self.sorter = []
            self.filter = []
            self._create_summary_page()
            self._create_dummy_page()

            # FIXME: This is an unfortunate work-around. If the area around the "+/New Log" button
            # is clicked, PyQSO will change to an empty page. This signal is used to stop this from happening.
            self.connect("switch-page", self._on_switch_page)

            for i in range(len(self.logs)):
                self._render_log(i)
            logging.debug("All logs rendered successfully.")

            self.update_summary()
            self.parent.toolbox.awards.count()

            context_id = self.parent.statusbar.get_context_id("Status")
            self.parent.statusbar.push(context_id, "Logbook: %s" % self.path)
            self.parent.toolbar.set_logbook_button_sensitive(False)
            self.parent.menu.set_logbook_item_sensitive(False)
            self.parent.menu.set_log_items_sensitive(True)
            self.parent.toolbar.filter_source.set_sensitive(True)

            self.show_all()

        else:
            logging.debug("Not connected to a logbook. No logs were opened.")

        return

    def close(self, widget=None):
        """ Close the logbook that is currently open. """

        disconnected = self.db_disconnect()
        if(disconnected):
            logging.debug("Closing all logs in the logbook...")
            while(self.get_n_pages() > 0):
                # Once a page is removed, the other pages get re-numbered,
                # so a 'for' loop isn't the best option here.
                self.remove_page(0)
            logging.debug("All logs now closed.")

            context_id = self.parent.statusbar.get_context_id("Status")
            self.parent.statusbar.push(context_id, "No logbook is currently open.")
            self.parent.toolbar.set_logbook_button_sensitive(True)
            self.parent.menu.set_logbook_item_sensitive(True)
            self.parent.menu.set_log_items_sensitive(False)
            self.parent.toolbar.filter_source.set_sensitive(False)
        else:
            logging.debug("Unable to disconnect from the database. No logs were closed.")
        return

    def db_connect(self, path):
        """ Create an SQL database connection to the Logbook's data source.

        :arg str path: The path of the database file.
        """

        logging.debug("Attempting to connect to the logbook database...")
        # Try setting up the SQL database connection
        try:
            self.db_disconnect()  # Destroy any existing connections first.
            self.connection = sqlite.connect(path)
            self.connection.row_factory = sqlite.Row
        except sqlite.Error as e:
            # PyQSO can't connect to the database.
            logging.exception(e)
            error(parent=self.parent, message="PyQSO cannot connect to the database. Check file permissions?")
            return False

        logging.debug("Database connection created successfully!")
        return True

    def db_disconnect(self):
        """ Destroy the connection to the Logbook's data source.

        :returns: True if the connection was successfully destroyed, and False otherwise.
        :rtype: bool
        """

        logging.debug("Cleaning up any existing database connections...")
        if(self.connection):
            try:
                self.connection.close()
            except sqlite.Error as e:
                logging.exception(e)
                return False
        else:
            logging.debug("Already disconnected. Nothing to do here.")
        return True

    def _create_dummy_page(self):
        """ Create a blank page in the Gtk.Notebook for the "+" (New Log) tab. """

        blank_treeview = Gtk.TreeView()
        # Allow the Log to be scrolled up/down
        sw = Gtk.ScrolledWindow()
        sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
        sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        sw.add(blank_treeview)
        vbox = Gtk.VBox()
        vbox.pack_start(sw, True, True, 0)

        # Add a "+" button to the tab
        hbox = Gtk.HBox(False, 0)
        icon = Gtk.Image.new_from_stock(Gtk.STOCK_ADD, Gtk.IconSize.MENU)
        button = Gtk.Button()
        button.set_relief(Gtk.ReliefStyle.NONE)
        button.set_focus_on_click(False)
        button.connect("clicked", self.new_log)
        button.add(icon)
        button.set_tooltip_text('New Log')
        hbox.pack_start(button, False, False, 0)
        hbox.show_all()
        vbox.show_all()

        self.insert_page(vbox, hbox, 1)
        self.show_all()
        self.set_current_page(0)
        return

    def _create_summary_page(self):
        """ Create a summary page containing the number of logs in the logbook, and the logbook's modification date. """

        vbox = Gtk.VBox()

        # Database name in large font at the top of the summary page
        hbox = Gtk.HBox()
        label = Gtk.Label(halign=Gtk.Align.START)
        label.set_markup("<span size=\"x-large\">%s</span>" % basename(self.path))
        hbox.pack_start(label, False, False, 6)
        vbox.pack_start(hbox, False, False, 4)

        hbox = Gtk.HBox()
        label = Gtk.Label("Number of logs: ", halign=Gtk.Align.START)
        hbox.pack_start(label, False, False, 6)
        self.summary["LOG_COUNT"] = Gtk.Label("0")
        hbox.pack_start(self.summary["LOG_COUNT"], False, False, 4)
        vbox.pack_start(hbox, False, False, 4)

        hbox = Gtk.HBox()
        label = Gtk.Label("Total number of QSOs: ", halign=Gtk.Align.START)
        hbox.pack_start(label, False, False, 6)
        self.summary["QSO_COUNT"] = Gtk.Label("0")
        hbox.pack_start(self.summary["QSO_COUNT"], False, False, 4)
        vbox.pack_start(hbox, False, False, 4)

        hbox = Gtk.HBox()
        label = Gtk.Label("Date modified: ", halign=Gtk.Align.START)
        hbox.pack_start(label, False, False, 6)
        self.summary["DATE_MODIFIED"] = Gtk.Label("0")
        hbox.pack_start(self.summary["DATE_MODIFIED"], False, False, 4)
        vbox.pack_start(hbox, False, False, 4)

        hseparator = Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL)
        vbox.pack_start(hseparator, False, False, 4)

        # Yearly statistics
        config = configparser.ConfigParser()
        have_config = (config.read(expanduser('~/.config/pyqso/preferences.ini')) != [])
        (section, option) = ("general", "show_yearly_statistics")
        if(have_config and config.has_option(section, option)):
            if(config.get("general", "show_yearly_statistics") == "True" and have_matplotlib):
                hbox = Gtk.HBox()
                label = Gtk.Label("Display statistics for year: ", halign=Gtk.Align.START)
                hbox.pack_start(label, False, False, 6)
                self.summary["YEAR_SELECT"] = Gtk.ComboBoxText()
                min_year, max_year = self._find_year_bounds()
                if min_year and max_year:
                    for year in range(max_year, min_year-1, -1):
                        self.summary["YEAR_SELECT"].append_text(str(year))
                self.summary["YEAR_SELECT"].append_text("")
                self.summary["YEAR_SELECT"].connect("changed", self._on_year_changed)
                hbox.pack_start(self.summary["YEAR_SELECT"], False, False, 6)
                vbox.pack_start(hbox, False, False, 4)

                self.summary["YEARLY_STATISTICS"] = Figure()
                canvas = FigureCanvas(self.summary["YEARLY_STATISTICS"])
                canvas.set_size_request(800, 250)
                canvas.show()
                vbox.pack_start(canvas, True, True, 4)

        # Summary tab label and icon.
        hbox = Gtk.HBox(False, 0)
        label = Gtk.Label("Summary  ")
        icon = Gtk.Image.new_from_stock(Gtk.STOCK_INDEX, Gtk.IconSize.MENU)
        hbox.pack_start(label, False, False, 0)
        hbox.pack_start(icon, False, False, 0)
        hbox.show_all()

        self.insert_page(vbox, hbox, 0)  # Append as a new tab
        self.show_all()

        return

    def _on_year_changed(self, combo):
        """ Re-plot the statistics for the year selected by the user. """

        # Clear figure
        self.summary["YEARLY_STATISTICS"].clf()
        self.summary["YEARLY_STATISTICS"].canvas.draw()

        # Get year to show statistics for.
        year = combo.get_active_text()
        try:
            year = int(year)
        except ValueError:
            # Empty year string.
            return

        # Number of contacts made each month
        contact_count_plot = self.summary["YEARLY_STATISTICS"].add_subplot(121)
        contact_count = self._get_annual_contact_count(year)

        # x-axis formatting based on the date
        contact_count_plot.bar(list(contact_count.keys()), list(contact_count.values()), color="k", width=15, align="center")
        formatter = DateFormatter("%b")
        contact_count_plot.xaxis.set_major_formatter(formatter)
        month_locator = MonthLocator()
        contact_count_plot.xaxis.set_major_locator(month_locator)
        contact_count_plot.set_ylabel("Number of QSOs")

        # Set x-axis upper limit based on the current month.
        contact_count_plot.xaxis_date()
        contact_count_plot.set_xlim([date(year-1, 12, 16), date(year, 12, 15)])  # Make a bit of space either side of January and December of the selected year.

        # Pie chart of all the modes used.
        mode_count_plot = self.summary["YEARLY_STATISTICS"].add_subplot(122)
        mode_count = self._get_annual_mode_count(year)
        (patches, texts, autotexts) = mode_count_plot.pie(list(mode_count.values()), labels=mode_count.keys(), autopct='%1.1f%%', shadow=False)
        for p in patches:
            # Make the patches partially transparent.
            p.set_alpha(0.75)
        mode_count_plot.set_title("Modes used")

        self.summary["YEARLY_STATISTICS"].canvas.draw()

        return

    def _find_year_bounds(self):
        """ Find the years of the oldest and newest QSOs across all logs in the logbook. """

        c = self.connection.cursor()
        max_years = []
        min_years = []
        for log in self.logs:
            query = "SELECT min(QSO_DATE), max(QSO_DATE) FROM %s" % (log.name)
            c.execute(query)
            years = c.fetchone()
            if years[0] and years[1]:
                min_years.append(int(years[0][:4]))
                max_years.append(int(years[1][:4]))

        if len(min_years) == 0 or max_years == 0:
            return None, None
        else:
            # Return the min and max across all logs.
            return min(min_years), max(max_years)

    def _get_annual_contact_count(self, year):
        """ Find the total number of contacts made in each month in the specified year. """

        contact_count = {}
        c = self.connection.cursor()

        for log in self.logs:
            query = "SELECT QSO_DATE, count(QSO_DATE) FROM %s WHERE QSO_DATE >= %d0101 AND QSO_DATE < %d0101 GROUP by QSO_DATE" % (log.name, year, year+1)
            c.execute(query)
            xy = c.fetchall()

            for i in range(len(xy)):
                date_str = xy[i][0]
                y = int(date_str[0:4])
                m = int(date_str[4:6])
                date = datetime(y, m, 1)  # Collect all contacts together by month.
                if date in contact_count.keys():
                    contact_count[date] += xy[i][1]
                else:
                    contact_count[date] = xy[i][1]

        return contact_count

    def _get_annual_mode_count(self, year):
        """ Find the total number of contacts made with each mode in a specified year. """

        mode_count = {}

        for log in self.logs:
            query = "SELECT MODE, count(MODE) FROM %s WHERE QSO_DATE >= %d0101 AND QSO_DATE < %d0101 GROUP by MODE" % (log.name, year, year+1)
            c = self.connection.cursor()
            c.execute(query)
            xy = c.fetchall()

            for i in range(len(xy)):
                mode = xy[i][0]
                if mode == "":
                    mode = "Unspecified"

                # Add to running total
                if mode in mode_count.keys():
                    mode_count[mode] += xy[i][1]
                else:
                    mode_count[mode] = xy[i][1]

        return mode_count

    def update_summary(self):
        """ Update the information presented on the summary page. """

        self.summary["LOG_COUNT"].set_label(str(self.get_number_of_logs()))
        self.summary["QSO_COUNT"].set_label(str(self.get_number_of_qsos()))
        try:
            t = datetime.fromtimestamp(getmtime(self.path)).strftime("%d %B %Y @ %H:%M")
            self.summary["DATE_MODIFIED"].set_label(str(t))
        except (IOError, OSError) as e:
            logging.exception(e)
        return

    def _on_switch_page(self, widget, label, new_page):
        """ Handle a tab/page change, and enable/disable the relevant Record-related buttons. """

        if(new_page == self.get_n_pages()-1):  # The last (right-most) tab is the "New Log" tab.
            self.stop_emission("switch-page")

        # Disable the record buttons if a log page is not selected.
        if(new_page == 0):
            self.parent.toolbar.set_record_buttons_sensitive(False)
            self.parent.menu.set_record_items_sensitive(False)
        else:
            self.parent.toolbar.set_record_buttons_sensitive(True)
            self.parent.menu.set_record_items_sensitive(True)
        return

    def new_log(self, widget=None):
        """ Create a new log in the logbook. """

        if(self.connection is None):
            return
        exists = True
        dialog = LogNameDialog(self.parent)
        while(exists):
            response = dialog.run()
            if(response == Gtk.ResponseType.OK):
                log_name = dialog.get_log_name()
                try:
                    with self.connection:
                        c = self.connection.cursor()
                        query = "CREATE TABLE %s (id INTEGER PRIMARY KEY AUTOINCREMENT" % log_name
                        for field_name in AVAILABLE_FIELD_NAMES_ORDERED:
                            s = ", %s TEXT" % field_name.lower()
                            query = query + s
                        query = query + ")"
                        c.execute(query)
                        exists = False
                except sqlite.Error as e:
                    logging.exception(e)
                    # Data is not valid - inform the user.
                    error(parent=self.parent, message="Database error. Try another log name.")
                    exists = True
            else:
                dialog.destroy()
                return

        dialog.destroy()

        l = Log(self.connection, log_name)  # Empty log
        l.populate()

        self.logs.append(l)
        self._render_log(self.get_number_of_logs()-1)
        self.update_summary()

        self.set_current_page(self.get_number_of_logs())
        return

    def delete_log(self, widget, page=None):
        """ Delete the log that is currently selected in the logbook.

        :arg Gtk.Widget page: An optional argument corresponding to the currently-selected page/tab.
        """
        if(self.connection is None):
            return

        if(page is None):
            page_index = self.get_current_page()  # Gets the index of the selected tab in the logbook
            if(page_index == 0):  # If we are on the Summary page...
                logging.debug("No log currently selected!")
                return
            else:
                page = self.get_nth_page(page_index)  # Gets the Gtk.VBox of the selected tab in the logbook

        log_index = self._get_log_index(name=page.get_name())
        log = self.logs[log_index]

        # We also need the page's index in order to remove it using remove_page below.
        # This may not be the same as what self.get_current_page() returns.
        page_index = self.page_num(page)

        if(page_index == 0 or page_index == self.get_n_pages()-1):  # Only the "New Log" tab is present (i.e. no actual logs in the logbook)
            logging.debug("No logs to delete!")
            return

        response = question(parent=self.parent, message="Are you sure you want to delete log %s?" % log.name)
        if(response == Gtk.ResponseType.YES):
            try:
                with self.connection:
                    c = self.connection.cursor()
                    c.execute("DROP TABLE %s" % log.name)
            except sqlite.Error as e:
                logging.exception(e)
                error(parent=self.parent, message="Database error. Could not delete the log.")
                return

            self.logs.pop(log_index)
            # Remove the log from the renderers too
            self.treeview.pop(log_index)
            self.treeselection.pop(log_index)
            self.sorter.pop(log_index)
            self.filter.pop(log_index)
            # And finally remove the tab in the Logbook
            self.remove_page(page_index)

        self.update_summary()
        self.parent.toolbox.awards.count()
        return

    def filter_logs(self, widget=None):
        """ Re-filter all the logs when the user-defined expression is changed. """
        for i in range(0, len(self.filter)):
            self.filter[i].refilter()
        return

    def _filter_by_callsign(self, model, iter, data):
        """ Filter all the logs in the logbook by the callsign field, based on a user-defined expression.

        :arg Gtk.TreeModel model: The model used to filter the log data.
        :arg Gtk.TreeIter iter: A pointer to a particular row in the model.
        :arg data: The user-defined expression to filter by.
        :returns: True if a record matches the expression, or if there is nothing to filter. Otherwise, returns False.
        :rtype: bool
        """
        value = model.get_value(iter, 1)
        callsign = self.parent.toolbar.filter_source.get_text()

        if(callsign is None or callsign == ""):
            # If there is nothing to filter with, then show all the records!
            return True
        else:
            # This should be case insensitive.
            # Also, we could use value[:][0:len(callsign))] if we wanted to match from the very start of each callsign.
            return callsign.upper() in value or callsign.lower() in value

    def _render_log(self, index):
        """ Render a Log in the Gtk.Notebook.

        :arg int index: The index of the Log (in the list of Logs) to render.
        """
        self.filter.append(self.logs[index].filter_new(root=None))
        # Set the callsign column as the column we want to filter by
        self.filter[index].set_visible_func(self._filter_by_callsign, data=None)
        self.sorter.append(Gtk.TreeModelSort(model=self.filter[index]))
        self.sorter[index].set_sort_column_id(0, Gtk.SortType.ASCENDING)

        self.treeview.append(Gtk.TreeView(self.sorter[index]))
        self.treeview[index].set_grid_lines(Gtk.TreeViewGridLines.BOTH)
        self.treeview[index].connect("row-activated", self.edit_record_callback)
        self.treeselection.append(self.treeview[index].get_selection())
        self.treeselection[index].set_mode(Gtk.SelectionMode.SINGLE)
        # Allow the Log to be scrolled up/down
        sw = Gtk.ScrolledWindow()
        sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
        sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        sw.add(self.treeview[index])
        vbox = Gtk.VBox()
        vbox.set_name(self.logs[index].name)  # Set a name for the tab itself so we can match it up with the associated Log object later.
        vbox.pack_start(sw, True, True, 0)

        # Add a close button to the tab
        hbox = Gtk.HBox(False, 0)
        label = Gtk.Label(self.logs[index].name)
        hbox.pack_start(label, False, False, 0)
        hbox.show_all()

        self.insert_page(vbox, hbox, index+1)  # Append the new log as a new tab

        # The first column of the logbook will always be the unique record index.
        # Let's append this separately to the field names.
        renderer = Gtk.CellRendererText()
        column = Gtk.TreeViewColumn("Index", renderer, text=0)
        column.set_resizable(True)
        column.set_min_width(50)
        column.set_clickable(True)
        column.set_sort_order(Gtk.SortType.ASCENDING)
        column.set_sort_indicator(True)
        column.connect("clicked", self.sort_log, 0)
        self.treeview[index].append_column(column)

        # Set up column names for each selected field
        field_names = AVAILABLE_FIELD_NAMES_ORDERED
        for i in range(0, len(field_names)):
            renderer = Gtk.CellRendererText()
            column = Gtk.TreeViewColumn(AVAILABLE_FIELD_NAMES_FRIENDLY[field_names[i]], renderer, text=i+1)
            column.set_resizable(True)
            column.set_min_width(50)
            column.set_clickable(True)

            # Special cases
            if(field_names[i] == "NOTES"):
                # Give the 'Notes' column some extra space, since this is likely to contain some long sentences...
                column.set_min_width(300)
                # ... but don't let it automatically re-size itself.
                column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)

            column.connect("clicked", self.sort_log, i+1)

            config = configparser.ConfigParser()
            have_config = (config.read(expanduser('~/.config/pyqso/preferences.ini')) != [])
            (section, option) = ("view", AVAILABLE_FIELD_NAMES_ORDERED[i].lower())
            if(have_config and config.has_option(section, option)):
                column.set_visible(config.get(section, option) == "True")
            self.treeview[index].append_column(column)

        self.show_all()
        return

    def _compare_date_and_time(self, model, row1, row2, user_data):
        """ Compare two rows (let's call them A and B) in a Gtk.ListStore, and sort by both date and time.

        :arg Gtk.TreeModel model: The model used to sort the log data.
        :arg Gtk.TreeIter row1: The pointer to row A.
        :arg Gtk.TreeIter row2: The pointer to row B.
        :arg user_data: The specific column from which to retrieve data for rows A and B.
        :returns: 1 if Row B's date/time is more recent than Row A's; 0 if both dates and times are the same; -1 if Row A's date/time is more recent than Row B's.
        :rtype: int
        """
        date1 = model.get_value(row1, user_data[0])
        date2 = model.get_value(row2, user_data[0])
        time1 = model.get_value(row1, user_data[1])
        time2 = model.get_value(row2, user_data[1])
        if(date1 < date2):
            return 1
        elif(date1 == date2):
            # If the dates are the same, then let's also sort by time.
            if(time1 > time2):
                return -1
            elif(time1 == time2):
                return 0
            else:
                return 1
        else:
            return -1

    def _compare_default(self, model, row1, row2, user_data):
        """ The default sorting function for all Gtk.ListStore objects.

        :arg Gtk.TreeModel model: The model used to sort the log data.
        :arg Gtk.TreeIter row1: The pointer to row A.
        :arg Gtk.TreeIter row2: The pointer to row B.
        :arg user_data: The specific column from which to retrieve data for rows A and B.
        :returns: 1 if the value of Row A's column value is less than Row B's column value; 0 if both values are the same; -1 if Row A's column value is greater than Row B's column value.
        :rtype: int
        """
        value1 = model.get_value(row1, user_data)
        value2 = model.get_value(row2, user_data)
        if(value1 < value2):
            return 1
        elif(value1 == value2):
            return 0
        else:
            return -1

    def sort_log(self, widget, column_index):
        """ Sort the log (that is currently selected) with respect to a given field.

        :arg int column_index: The index of the column to sort by.
        """

        log_index = self._get_log_index()
        column = self.treeview[log_index].get_column(column_index)

        if(AVAILABLE_FIELD_NAMES_ORDERED[column_index-1] == "QSO_DATE"):
            # If the field being sorted is the QSO_DATE, then also sort by the TIME_ON field so we get the
            # correct chronological order.
            # Note: This assumes that the TIME_ON field is always immediately to the right of the QSO_DATE field.
            self.sorter[log_index].set_sort_func(column_index, self._compare_date_and_time, user_data=[column_index, column_index+1])
        else:
            self.sorter[log_index].set_sort_func(column_index, self._compare_default, user_data=column_index)

        # If we are operating on the currently-sorted column...
        if(self.sorter[log_index].get_sort_column_id()[0] == column_index):
            order = column.get_sort_order()
            # ...then check if we need to reverse the order of searching.
            if(order == Gtk.SortType.ASCENDING):
                self.sorter[log_index].set_sort_column_id(column_index, Gtk.SortType.DESCENDING)
                column.set_sort_order(Gtk.SortType.DESCENDING)
            else:
                self.sorter[log_index].set_sort_column_id(column_index, Gtk.SortType.ASCENDING)
                column.set_sort_order(Gtk.SortType.ASCENDING)
        else:
            # Otherwise, change to the new sorted column. Default to ASCENDING order.
            self.sorter[log_index].set_sort_column_id(column_index, Gtk.SortType.ASCENDING)
            column.set_sort_order(Gtk.SortType.ASCENDING)

            # Show an arrow pointing in the direction of the sorting.
            # (First we need to remove the arrow from the previously-sorted column.
            # Since we don't know which one that was, just remove the arrow from all columns
            # and start again. This only loops over a few dozen columns at most, so
            # hopefully it won't take too much time.)
            for i in range(0, len(AVAILABLE_FIELD_NAMES_ORDERED)):
                column = self.treeview[log_index].get_column(i)
                column.set_sort_indicator(False)
            column = self.treeview[log_index].get_column(column_index)
            column.set_sort_indicator(True)
        return

    def rename_log(self, widget=None):
        """ Rename the log that is currently selected. """
        if(self.connection is None):
            return
        page_index = self.get_current_page()
        if(page_index == 0):  # If we are on the Summary page...
            logging.debug("No log currently selected!")
            return
        page = self.get_nth_page(page_index)  # Gets the Gtk.VBox of the selected tab in the logbook
        old_log_name = page.get_name()

        log_index = self._get_log_index(name=old_log_name)

        exists = True
        dialog = LogNameDialog(self.parent, title="Rename Log", name=old_log_name)
        while(exists):
            response = dialog.run()
            if(response == Gtk.ResponseType.OK):
                new_log_name = dialog.get_log_name()
                try:
                    with self.connection:
                        c = self.connection.cursor()
                        query = "ALTER TABLE %s RENAME TO %s" % (old_log_name, new_log_name)
                        c.execute(query)
                        exists = False
                except sqlite.Error as e:
                    logging.exception(e)
                    # Data is not valid - inform the user.
                    error(parent=self.parent, message="Database error. Try another log name.")
                    exists = True
            else:
                dialog.destroy()
                return

        dialog.destroy()

        # Remember to change the Log object's name...
        self.logs[log_index].name = new_log_name

        # ...and the page's name
        page.set_name(self.logs[log_index].name)

        # ...and update the tab's label
        hbox = Gtk.HBox(False, 0)
        label = Gtk.Label(new_log_name)
        hbox.pack_start(label, False, False, 0)
        hbox.show_all()
        self.set_tab_label(page, hbox)

        # The number of logs will obviously stay the same, but
        # we want to update the logbook's modification date.
        self.update_summary()

        return

    def import_log(self, widget=None):
        """ Import a log from an ADIF file. """
        dialog = Gtk.FileChooserDialog("Import ADIF Log File",
                                       self.parent,
                                       Gtk.FileChooserAction.OPEN,
                                      (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
                                       Gtk.STOCK_OPEN, Gtk.ResponseType.OK))
        filter = Gtk.FileFilter()
        filter.set_name("All ADIF files (*.adi, *.ADI)")
        filter.add_pattern("*.adi")
        filter.add_pattern("*.ADI")
        dialog.add_filter(filter)

        filter = Gtk.FileFilter()
        filter.set_name("All files")
        filter.add_pattern("*")
        dialog.add_filter(filter)

        response = dialog.run()
        if(response == Gtk.ResponseType.OK):
            path = dialog.get_filename()
        else:
            path = None
        dialog.destroy()

        if(path is None):
            logging.debug("No file path specified.")
            return

        dialog = LogNameDialog(self.parent, title="Import Log")
        while(True):
            response = dialog.run()
            if(response == Gtk.ResponseType.OK):
                log_name = dialog.get_log_name()
                if(self.log_name_exists(log_name)):
                    # Import into existing log
                    exists = True
                    l = self.logs[self._get_log_index(name=log_name)]
                    response = question(parent=self.parent, message="Are you sure you want to import into an existing log?")
                    if(response == Gtk.ResponseType.YES):
                        break
                elif(self.log_name_exists(log_name) is None):
                    # Could not determine if the log name exists. It's safer to stop here than to try to add a new log.
                    error(parent=self.parent, message="Database error. Could not check if the log name exists.")
                    dialog.destroy()
                    return
                else:
                    # Create a new log with the name the user supplies
                    exists = False
                    try:
                        with self.connection:
                            c = self.connection.cursor()
                            query = "CREATE TABLE %s (id INTEGER PRIMARY KEY AUTOINCREMENT" % log_name
                            for field_name in AVAILABLE_FIELD_NAMES_ORDERED:
                                s = ", %s TEXT" % field_name.lower()
                                query = query + s
                            query = query + ")"
                            c.execute(query)
                            l = Log(self.connection, log_name)
                            break
                    except sqlite.Error as e:
                        logging.exception(e)
                        # Data is not valid - inform the user.
                        error(parent=self.parent, message="Database error. Try another log name.")
            else:
                dialog.destroy()
                return

        dialog.destroy()

        adif = ADIF()
        logging.debug("Importing records from the ADIF file with path: %s" % path)
        records = adif.read(path)
        l.add_record(records)
        l.populate()

        if(not exists):
            self.logs.append(l)
            self._render_log(self.get_number_of_logs()-1)
        self.update_summary()
        self.parent.toolbox.awards.count()

        return

    def export_log(self, widget=None):
        """ Export the log (that is currently selected) to an ADIF file. """
        page_index = self.get_current_page()  # Gets the index of the selected tab in the logbook
        if(page_index == 0):  # If we are on the Summary page...
            logging.debug("No log currently selected!")
            return

        log_index = self._get_log_index()
        log = self.logs[log_index]

        dialog = Gtk.FileChooserDialog("Export Log to File",
                                       self.parent,
                                       Gtk.FileChooserAction.SAVE,
                                      (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
                                       Gtk.STOCK_SAVE, Gtk.ResponseType.OK))
        dialog.set_do_overwrite_confirmation(True)

        filter = Gtk.FileFilter()
        filter.set_name("All ADIF files (*.adi, *.ADI)")
        filter.add_pattern("*.adi")
        filter.add_pattern("*.ADI")
        dialog.add_filter(filter)

        filter = Gtk.FileFilter()
        filter.set_name("All files")
        filter.add_pattern("*")
        dialog.add_filter(filter)

        response = dialog.run()
        if(response == Gtk.ResponseType.OK):
            path = dialog.get_filename()
        else:
            path = None
        dialog.destroy()

        if(path is None):
            logging.debug("No file path specified.")
        else:
            adif = ADIF()
            records = log.get_all_records()
            if(records is not None):
                adif.write(records, path)
            else:
                error(self.parent, "Could not retrieve the records from the SQL database. No records have been exported.")
        return

    def print_log(self, widget=None):
        """ Print all the records in the log (that is currently selected).
        Note that only a few important fields are printed because of the restricted width of the page. """
        page_index = self.get_current_page()  # Gets the index of the selected tab in the logbook
        if(page_index == 0):  # If we are on the Summary page...
            logging.debug("No log currently selected!")
            return
        log_index = self._get_log_index()
        log = self.logs[log_index]

        self.text_to_print = "Callsign\t---\tDate\t---\tTime\t---\tFrequency\t---\tMode\n"
        records = log.get_all_records()
        if(records is not None):
            for r in records:
                self.text_to_print += str(r["CALL"]) + "\t---\t" + str(r["QSO_DATE"]) + "\t---\t" + str(r["TIME_ON"]) + "\t---\t" + str(r["FREQ"]) + "\t---\t" + str(r["MODE"]) + "\n"

            action = Gtk.PrintOperationAction.PRINT_DIALOG
            operation = Gtk.PrintOperation()
            operation.set_default_page_setup(Gtk.PageSetup())
            operation.set_unit(Gtk.Unit.MM)

            operation.connect("begin_print", self._begin_print)
            operation.connect("draw_page", self._draw_page)
            operation.run(action, parent=self.parent)
        else:
            error(self.parent, "Could not retrieve the records from the SQL database. No records have been printed.")
        return

    def _begin_print(self, operation, context):
        """ Specify the layout/position/font of the text on the pages to be printed.

        :arg Gtk.PrintOperation operation: The printing API.
        :arg Gtk.PrintContext context: Used to draw/render the pages to print.
        """
        width = context.get_width()
        height = context.get_height()
        layout = context.create_pango_layout()
        layout.set_font_description(Pango.FontDescription("normal 10"))
        layout.set_width(int(width*Pango.SCALE))
        layout.set_text(self.text_to_print, -1)

        number_of_pages = 0
        page_height = 0
        for line in range(0, layout.get_line_count()):
            layout_line = layout.get_line(line)
            ink_rectangle, logical_rectangle = layout_line.get_extents()
            self.line_height = logical_rectangle.height/1024.0 + 3
            page_height += self.line_height
            if(page_height + self.line_height > height):
                number_of_pages += 1
                page_height = self.line_height
        operation.set_n_pages(number_of_pages + 1)
        self.text_to_print = self.text_to_print.split("\n")
        return

    def _draw_page(self, operation, context, page_number):
        """ Render the QSO details on the page.

        :arg Gtk.PrintOperation operation: The printing API.
        :arg Gtk.PrintContext context: Used to draw/render the pages to print.
        :arg int page_number: The current page number.
        """
        cr = context.get_cairo_context()
        cr.set_source_rgb(0, 0, 0)
        layout = context.create_pango_layout()

        current_line_number = 0
        for line in self.text_to_print:
            layout.set_text(line, -1)
            cr.move_to(5, current_line_number*self.line_height)
            PangoCairo.update_layout(cr, layout)
            PangoCairo.show_layout(cr, layout)
            current_line_number += 1
            if(current_line_number*self.line_height > context.get_height()):
                for j in range(0, current_line_number):
                    self.text_to_print.pop(0)  # Remove what has been printed already before draw_page is called again
                break
        return

    def add_record_callback(self, widget):
        """ A callback function used to add a particular record/QSO. """
        # Get the log index
        try:
            log_index = self._get_log_index()
            if(log_index is None):
                raise ValueError("The log index could not be determined. Perhaps you tried adding a record when the Summary page was selected?")
        except ValueError as e:
            error(self.parent, e)
            return
        log = self.logs[log_index]

        # Keep the dialog open after adding a record?
        config = configparser.ConfigParser()
        have_config = (config.read(expanduser('~/.config/pyqso/preferences.ini')) != [])
        (section, option) = ("general", "keep_open")
        if(have_config and config.has_option(section, option)):
            keep_open = config.get("general", "keep_open") == "True"
        else:
            keep_open = False
        adif = ADIF()

        exit = False
        while not exit:
            dialog = RecordDialog(parent=self.parent, log=log, index=None)

            all_valid = False  # Are all the field entries valid?

            # Shall we exit the while loop (and therefore close the Add Record dialog)?
            if keep_open:
                exit = False
            else:
                exit = True

            while not all_valid:
                # This while loop gives the user infinite attempts at giving valid data.
                # The add/edit record window will stay open until the user gives valid data,
                # or until the Cancel button is clicked.
                all_valid = True
                response = dialog.run()
                if(response == Gtk.ResponseType.OK):
                    fields_and_data = {}
                    field_names = AVAILABLE_FIELD_NAMES_ORDERED
                    for i in range(0, len(field_names)):
                        # Validate user input.
                        fields_and_data[field_names[i]] = dialog.get_data(field_names[i])
                        if(not(adif.is_valid(field_names[i], fields_and_data[field_names[i]], AVAILABLE_FIELD_NAMES_TYPES[field_names[i]]))):
                            # Data is not valid - inform the user.
                            error(parent=self.parent, message="The data in field \"%s\" is not valid!" % field_names[i])
                            all_valid = False
                            break  # Don't check the other data until the user has fixed the current one.

                    if(all_valid):
                        # All data has been validated, so we can go ahead and add the new record.
                        log.add_record(fields_and_data)
                        self.update_summary()
                        self.parent.toolbox.awards.count()
                        # Select the new Record's row in the treeview.
                        number_of_records = log.get_number_of_records()
                        if(number_of_records is not None):
                            self.treeselection[log_index].select_path(number_of_records)
                else:
                    exit = True
                    break
            dialog.destroy()
        return

    def delete_record_callback(self, widget):
        """ A callback function used to delete a particular record/QSO. """

        # Get the log index
        try:
            log_index = self._get_log_index()
            if(log_index is None):
                raise ValueError("The log index could not be determined. Perhaps you tried deleting a record when the Summary page was selected?")
        except ValueError as e:
            error(self.parent, e)
            return
        log = self.logs[log_index]

        (sort_model, path) = self.treeselection[log_index].get_selected_rows()  # Get the selected row in the log
        try:
            sort_iter = sort_model.get_iter(path[0])
            filter_iter = self.sorter[log_index].convert_iter_to_child_iter(sort_iter)
            # ...and the ListStore model (i.e. the log) is a child of the filter model.
            child_iter = self.filter[log_index].convert_iter_to_child_iter(filter_iter)
            row_index = log.get_value(child_iter, 0)
        except IndexError:
            logging.debug("Trying to delete a record, but there are no records in the log!")
            return

        response = question(parent=self.parent, message="Are you sure you want to delete record %d?" % row_index)
        if(response == Gtk.ResponseType.YES):
            # Deletes the record with index 'row_index' from the Records list.
            # 'iter' is needed to remove the record from the ListStore itself.
            log.delete_record(row_index, iter=child_iter)
            self.update_summary()
            self.parent.toolbox.awards.count()
        return

    def edit_record_callback(self, widget, path, view_column):
        """ A callback function used to edit a particular record/QSO.
        Note that the widget, path and view_column arguments are not used,
        but need to be passed in since they associated with the row-activated signal
        which is generated when the user double-clicks on a record. """

        # Get the log index
        try:
            log_index = self._get_log_index()
            if(log_index is None):
                raise ValueError("The log index could not be determined. Perhaps you tried editing a record when the Summary page was selected?")
        except ValueError as e:
            error(self.parent, e)
            return
        log = self.logs[log_index]

        (sort_model, path) = self.treeselection[log_index].get_selected_rows()  # Get the selected row in the log
        try:
            sort_iter = sort_model.get_iter(path[0])
            filter_iter = self.sorter[log_index].convert_iter_to_child_iter(sort_iter)
            # ...and the ListStore model (i.e. the log) is a child of the filter model.
            child_iter = self.filter[log_index].convert_iter_to_child_iter(filter_iter)
            row_index = log.get_value(child_iter, 0)
        except IndexError:
            logging.debug("Could not find the selected row's index!")
            return

        dialog = RecordDialog(parent=self.parent, log=self.logs[log_index], index=row_index)
        all_valid = False  # Are all the field entries valid?

        adif = ADIF()
        while(not all_valid):
            # This while loop gives the user infinite attempts at giving valid data.
            # The add/edit record window will stay open until the user gives valid data,
            # or until the Cancel button is clicked.
            all_valid = True
            response = dialog.run()
            if(response == Gtk.ResponseType.OK):
                fields_and_data = {}
                field_names = AVAILABLE_FIELD_NAMES_ORDERED
                for i in range(0, len(field_names)):
                    # Validate user input.
                    fields_and_data[field_names[i]] = dialog.get_data(field_names[i])
                    if(not(adif.is_valid(field_names[i], fields_and_data[field_names[i]], AVAILABLE_FIELD_NAMES_TYPES[field_names[i]]))):
                        # Data is not valid - inform the user.
                        error(parent=self.parent, message="The data in field \"%s\" is not valid!" % field_names[i])
                        all_valid = False
                        break  # Don't check the other fields until the user has fixed the current field's data.

                if(all_valid):
                    # All data has been validated, so we can go ahead and update the record.
                    record = log.get_record_by_index(row_index)
                    if(record is None):
                        message = "Could not retrieve record with row_index %d from the SQL database. The record has not been edited." % row_index
                        logging.error(message)
                        error(parent=self.parent, message=message)
                    else:
                        for i in range(0, len(field_names)):
                            # Check whether the data has actually changed. Database updates can be expensive.
                            if(record[field_names[i].lower()] != fields_and_data[field_names[i]]):
                                # Update the record in the database and then in the ListStore.
                                # We add 1 onto the column_index here because we don't want to consider the index column.
                                log.edit_record(row_index, field_names[i], fields_and_data[field_names[i]], iter=child_iter, column_index=i+1)
                        self.update_summary()
                        self.parent.toolbox.awards.count()

        dialog.destroy()
        return

    def remove_duplicates_callback(self, widget=None):
        """ Remove duplicate records in a log.
        Detecting duplicate records is done based on the CALL, QSO_DATE, TIME_ON, FREQ, and MODE fields. """
        logging.debug("Removing duplicate records...")

        log_index = self._get_log_index()
        log = self.logs[log_index]

        (number_of_duplicates, number_of_duplicates_removed) = log.remove_duplicates()
        info(self.parent, "Found %d duplicate(s). Successfully removed %d duplicate(s)." % (number_of_duplicates, number_of_duplicates_removed))
        return

    def get_number_of_logs(self):
        """ Return the total number of logs in the logbook.

        :returns: The total number of logs in the logbook.
        :rtype: int
        """
        return len(self.logs)

    def get_number_of_qsos(self):
        """ Return the total number of QSOs/records in the whole logbook.

        :returns: The total number of QSOs/records in the whole logbook.
        :rtype: int
        """
        total = 0
        for log in self.logs:
            total += log.get_number_of_records()
        return total

    def log_name_exists(self, table_name):
        """ Determine whether a Log object with a given name exists in the SQL database.

        :arg str table_name: The name of the log (i.e. the name of the table in the SQL database).
        :returns: True if the log name already exists in the logbook; False if it does not already exist; None if there is a database error.
        :rtype: bool or None
        """
        try:
            with self.connection:
                c = self.connection.cursor()
                c.execute("SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE name=?)", [table_name])
                exists = c.fetchone()
            if(exists[0] == 1):
                return True
            else:
                return False
        except (sqlite.Error, IndexError) as e:
            logging.exception(e)  # Database error. PyQSO could not check if the log name exists.
            return None

    def _get_log_index(self, name=None):
        """ Given the name of a log, return its index in the list of Log objects.

        :arg str name: The name of the log. If None, use the name of the currently-selected log.
        :returns: The index of the named log in the list of Log objects.
        :rtype: int
        """
        if(name is None):
            # If no page name is supplied, then just use the currently selected page
            page_index = self.get_current_page()  # Gets the index of the selected tab in the logbook
            if(page_index == 0 or page_index == self.get_n_pages()-1):
                # We either have the Summary page, or the "+" (add log) dummy page.
                logging.debug("No log currently selected!")
                return None
            name = self.get_nth_page(page_index).get_name()
        # If a page of the logbook (and therefore a Log object) gets deleted,
        # then the page_index may not correspond to the index of the log in the self.logs list.
        # Therefore, we have to search for the tab with the same name as the log.
        for i in range(0, len(self.logs)):
            if(self.logs[i].name == name):
                log_index = i
                break
        return log_index


class TestLogbook(unittest.TestCase):

    """ The unit tests for the Logbook class. """

    def setUp(self):
        """ Set up the Logbook object and connection to the test database needed for the unit tests. """
        import os
        self.logbook = Logbook(parent=None)
        success = self.logbook.db_connect(os.path.dirname(os.path.realpath(__file__))+"/unittest_resources/test.db")
        assert success

    def tearDown(self):
        """ Disconnect from the test database. """
        success = self.logbook.db_disconnect()
        assert success

    def test_log_name_exists(self):
        """ Check that only the log called 'test' exists. """
        assert self.logbook.log_name_exists("test")  # Log 'test' exists.
        assert not self.logbook.log_name_exists("hello")  # Log 'hello' should not exist.

if(__name__ == '__main__'):
    unittest.main()
