const St           = imports.gi.St;
const Gio          = imports.gi.Gio
const Gtk          = imports.gi.Gtk;
const GLib         = imports.gi.GLib;
const Clutter      = imports.gi.Clutter;
const GnomeDesktop = imports.gi.GnomeDesktop;
const Main         = imports.ui.main;
const ByteArray = imports.byteArray;
const Signals      = imports.signals;
const Mainloop     = imports.mainloop;


const ME = imports.misc.extensionUtils.getCurrentExtension();


const Gettext  = imports.gettext.domain(ME.metadata['gettext-domain']);
const _        = Gettext.gettext;
const ngettext = Gettext.ngettext;


const SIG_MANAGER  = ME.imports.lib.signal_manager;
const KEY_MANAGER  = ME.imports.lib.keybinding_manager;
const MISC_UTILS   = ME.imports.lib.misc_utils;


const G = ME.imports.sections.todo.GLOBAL;


const TASK                 = ME.imports.sections.todo.task_item;
const VIEW_MANAGER         = ME.imports.sections.todo.view_manager;
const TIME_TRACKER         = ME.imports.sections.todo.time_tracker;

const VIEW_STATS           = ME.imports.sections.todo.view__stats;
const VIEW_CLEAR           = ME.imports.sections.todo.view__clear_tasks;
const VIEW_SORT            = ME.imports.sections.todo.view__sort;
const VIEW_DEFAULT         = ME.imports.sections.todo.view__default;
const VIEW_SEARCH          = ME.imports.sections.todo.view__search;
const VIEW_LOADING         = ME.imports.sections.todo.view__loading;
const VIEW_FILTERS         = ME.imports.sections.todo.view__filters;
const VIEW_TASK_EDITOR     = ME.imports.sections.todo.view__task_editor;
const VIEW_FILE_SWITCHER   = ME.imports.sections.todo.view__file_switcher;
const VIEW_KANBAN_SWITCHER = ME.imports.sections.todo.view__kanban_switcher;


const CACHE_FILE = '~/.cache/timepp_gnome_shell_extension/timepp_todo.json';


// =====================================================================
// @@@ Main
//
// @ext      : obj (main extension object)
// @settings : obj (extension settings)
//
// @signals:
//   - 'new-day' (new day started) (returns string in yyyy-mm-dd iso format)
//   - 'tasks-changed'
// =====================================================================
var SectionMain = class SectionMain extends ME.imports.sections.section_base.SectionBase {
    constructor (section_name, ext, settings) {
        super(section_name, ext, settings);
        this.actor.add_style_class_name('todo-section');

        this.separate_menu = this.settings.get_boolean('todo-separate-menu');

        this.cache_file   = null;
        this.cache        = null;
        this.sigm         = new SIG_MANAGER.SignalManager();
        this.keym         = new KEY_MANAGER.KeybindingManager(this.settings);
        this.time_tracker = null;

        this.view_manager = new VIEW_MANAGER.ViewManager(this.ext, this);

        // The view manager only allows one view to be visible at a time; however,
        // since the stats view uses the fullscreen iface, it is orthogonal to
        // the other views, so we don't use the view manager for it.
        this.stats_view = new VIEW_STATS.StatsView(this.ext, this, 0);


        //
        // init cache file
        //
        try {
            this.cache_file = MISC_UTILS.file_new_for_path(CACHE_FILE);

            let cache_format_version =
                ME.metadata['cache-file-format-version'].todo;

            if (this.cache_file.query_exists(null)) {
                let [, contents] = this.cache_file.load_contents(null);
                this.cache = JSON.parse(ByteArray.toString(contents));
            }

            if (!this.cache || !this.cache.format_version ||
                this.cache.format_version !== cache_format_version) {

                this.cache = {
                    format_version: cache_format_version,

                    // array [of G.TODO_RECORD]
                    todo_files: [],
                };
            }
        } catch (e) {
            logError(e);
            return;
        }


        this.create_tasks_mainloop_id = null;


        // We use this for tracking when a new day begins.
        this.wallclock = new GnomeDesktop.WallClock();


        // Track how many tasks have a particular proj/context/prio, a
        this.stats = null;
        this._reset_stats_obj();


        // ref to current todo record in cache file
        this.current_todo_file = null;


        // A GFile to the todo.txt file, GMonitor.
        this.todo_txt_file     = null;
        this.todo_file_monitor = null;


        // All task objects.
        this.tasks = [];


        //
        // keybindings
        //
        this.keym.add('todo-keybinding-open', () => {
            this.ext.open_menu(this.section_name);
            this.show_view__default();
        });
        this.keym.add('todo-keybinding-open-to-add', () => {
            this.ext.open_menu(this.section_name);
            this.show_view__task_editor();
        });
        this.keym.add('todo-keybinding-open-to-search', () => {
            this.ext.open_menu(this.section_name);
            this.show_view__search();
        });
        this.keym.add('todo-keybinding-open-to-stats', () => {
            this.show_view__time_tracker_stats();
        });
        this.keym.add('todo-keybinding-open-to-switch-files', () => {
            this.ext.open_menu(this.section_name);
            this.show_view__file_switcher();
        });
        this.keym.add('todo-keybinding-open-todotxt-file', () => {
            if (! this.todo_txt_file) return;
            let path = this.todo_txt_file.get_path();
            if (path) MISC_UTILS.open_file_path(path);
        });


        //
        // panel item
        //
        this.panel_item.actor.add_style_class_name('todo-panel-item');
        this.panel_item.icon.gicon = MISC_UTILS.getIcon('timepp-todo-symbolic');
        this._toggle_panel_item_mode();


        //
        // listen
        //
        this.sigm.connect(this.settings, 'changed::todo-separate-menu', () => {
            this.separate_menu = this.settings.get_boolean('todo-separate-menu');
            this.ext.update_panel_items();
        });
        this.sigm.connect(this.settings, 'changed::todo-task-width', () => {
            let width = this.settings.get_int('todo-task-width');
            for (let task of this.tasks) task.actor.width = width;
        });
        this.sigm.connect(this.wallclock, 'notify::clock', () => {
            let t = GLib.DateTime.new_now(this.wallclock.timezone);
            t     = t.format('%H:%M');
            if (t === '00:00') this._on_new_day_started();
        });
        this.sigm.connect(this.settings, 'changed::todo-panel-mode', () => this._toggle_panel_item_mode());
        this.sigm.connect(this.ext, 'custom-css-changed', () => this._on_custom_css_changed());

        //
        // finally
        //
        this._init_todo_file();
    }

    disable_section () {
        if (this.create_tasks_mainloop_id) {
            Mainloop.source_remove(this.create_tasks_mainloop_id);
            this.create_tasks_mainloop_id = null;
        }

        if (this.time_tracker) {
            this.time_tracker.close();
            this.time_tracker = null;
        }

        if (this.stats_view) {
            this.stats_view.destroy();
            this.stats_view = null;
        }

        this._disable_todo_file_monitor();
        this.sigm.clear();
        this.keym.clear();

        this.view_manager.close_current_view();
        this.view_manager      = null;
        this.tasks             = [];

        super.disable_section();
    }

    _init_todo_file () {
        this.show_view__loading(true);
        this.view_manager.lock = true;

        // reset
        {
            if (this.create_tasks_mainloop_id) {
                Mainloop.source_remove(this.create_tasks_mainloop_id);
                this.create_tasks_mainloop_id = null;
            }

            if (this.time_tracker) {
                this.time_tracker.close();
                this.time_tracker = null;
            }

            if (this.todo_file_monitor) {
                this.todo_file_monitor.cancel();
                this.todo_file_monitor = null;
            }

            this.stats.priorities.clear();
            this.stats.contexts.clear();
            this.stats.projects.clear();
        }

        try {
            if (this.cache.todo_files.length === 0) {
                this.show_view__file_switcher(true);
                this.view_manager.lock = true;
                return;
            }

            this.current_todo_file = null;
            let current = this.get_current_todo_file();

            if (!current) {
                this.show_view__file_switcher(true);
                this.view_manager.lock = true;
                return;
            }

            this.todo_txt_file = MISC_UTILS.file_new_for_path(current.todo_file);
            if (! this.todo_txt_file.query_exists(null)) this.todo_txt_file.create(Gio.FileCreateFlags.NONE, null);
            this._enable_todo_file_monitor();
        } catch (e) {
            this.show_view__file_switcher(true);
            this.view_manager.lock = true;
            logError(e);
            Main.notify(_('Unable to load todo file'));
            return;
        }

        let [, lines] = this.todo_txt_file.load_contents(null);
        lines = ByteArray.toString(lines).split(/\r?\n/).filter((l) => /\S/.test(l));

        this.create_tasks(lines, () => {
            let needs_write = this._check_dates();
            this.on_tasks_changed(needs_write);
            this.time_tracker = new TIME_TRACKER.TimeTracker(this.ext, this);
        });
    }

    _disable_todo_file_monitor () {
        if (this.todo_file_monitor) {
            this.todo_file_monitor.cancel();
            this.todo_file_monitor = null;
        }
    }

    _enable_todo_file_monitor () {
        [this.todo_file_monitor,] =
            MISC_UTILS.file_monitor(this.todo_txt_file, () => this._on_todo_file_changed());
    }

    store_cache () {
        if (! this.cache_file) return;

        if(! this.cache_file.query_exists(null))
            this.cache_file.create(Gio.FileCreateFlags.NONE, null);

        this.cache_file.replace_contents(JSON.stringify(this.cache, null, 2),
            null, false, Gio.FileCreateFlags.REPLACE_DESTINATION, null);
    }

    get_current_todo_file () {
        if (this.current_todo_file) return this.current_todo_file;

        for (let it of this.cache.todo_files) {
            if (it.active) {
                this.current_todo_file = it;
                break;
            }
        }

        return this.current_todo_file;
    }

    write_tasks_to_file () {
        this._disable_todo_file_monitor();

        let content = '';
        for (let it of this.tasks) content += it.task_str + '\n';

        this.todo_txt_file.replace_contents(content, null, false,
            Gio.FileCreateFlags.REPLACE_DESTINATION, null);

        this._enable_todo_file_monitor();
    }

    _on_todo_file_changed (event_type) {
        this._init_todo_file();
    }

    _on_new_day_started () {
        this.emit('new-day', MISC_UTILS.date_yyyymmdd());
        if (this._check_dates()) this.on_tasks_changed(true, true);
    }

    _check_dates () {
        let today          = MISC_UTILS.date_yyyymmdd();
        let tasks_updated  = false;
        let recurred_tasks = 0;
        let deferred_tasks = 0;

        for (let task of this.tasks) {
            if (task.check_recurrence()) {
                tasks_updated = true;
                recurred_tasks++;
            }

            if (task.check_deferred_tasks(today)) {
                tasks_updated = true;
                deferred_tasks++;
            }

            task.update_dates_markup();
        }

        if (tasks_updated) {
            if (recurred_tasks > 0) {
                Main.notify(ngettext('%d task has recurred',
                                     '%d tasks have recurred',
                                      recurred_tasks).format(recurred_tasks));
            }

            if (deferred_tasks > 0) {
                Main.notify(ngettext('%d deferred task has been opened',
                                     '%d deferred tasks have been opened',
                                      deferred_tasks).format(deferred_tasks));
            }
        }

        return tasks_updated;
    }

    _on_custom_css_changed () {
        for (let task of this.tasks) {
            task.update_body_markup();
            task.update_dates_markup();
        }
    }

    // The maps have the structure:
    // @key : string  (a context/project/priority)
    // @val : natural (number of tasks that have that @key)
    _reset_stats_obj () {
        this.stats = {
            deferred_tasks        : 0,
            recurring_completed   : 0,
            recurring_incompleted : 0,
            hidden                : 0,
            completed             : 0,
            no_priority           : 0,
            priorities            : new Map(),
            contexts              : new Map(),
            projects              : new Map(),
        };
    }

    _toggle_panel_item_mode () {
        if (this.settings.get_enum('todo-panel-mode') === 0)
            this.panel_item.set_mode('icon');
        else if (this.settings.get_enum('todo-panel-mode') === 1)
            this.panel_item.set_mode('text');
        else
            this.panel_item.set_mode('icon_text');
    }

    // Create task objects from the given task strings and add them to the
    // this.tasks array.
    //
    // Make sure to call this.on_tasks_changed() soon after calling this func.
    //
    // @todo_strings : array (of strings; each string is a line in todo.txt file)
    // @callback     : func
    create_tasks (todo_strings, callback) {
        if (this.create_tasks_mainloop_id) {
            Mainloop.source_remove(this.create_tasks_mainloop_id);
            this.create_tasks_mainloop_id = null;
        }

        // Since we are reusing already instantiated objects, get rid of any
        // excess task object.
        //
        // @NOTE Reusing old objects can be the source of evil...
        {
            let len = todo_strings.length;
            while (this.tasks.length > len) this.tasks.pop().actor.destroy();
        }

        this.create_tasks_mainloop_id = Mainloop.idle_add(() => {
            this._create_tasks__finish(0, todo_strings, callback);
        });
    }

    _create_tasks__finish (i, todo_strings, callback) {
        if (i === todo_strings.length) {
            if (typeof(callback) === 'function') callback();
            this.create_tasks_mainloop_id = null;
            return;
        }

        let str = todo_strings[i];

        if (this.tasks[i])
            this.tasks[i].reset(false, str);
        else
            this.tasks.push(new TASK.TaskItem(this.ext, this, str, false));

        this.create_tasks_mainloop_id = Mainloop.idle_add(() => {
            this._create_tasks__finish(++i, todo_strings, callback);
        });
    }

    on_tasks_changed (write_to_file = true, refresh_default_view = false) {
        //
        // Update stats obj
        //
        {
            this._reset_stats_obj();

            let n, proj, context;

            for (let task of this.tasks) {
                if (task.is_deferred) {
                    this.stats.deferred_tasks++;
                    continue;
                }

                if (task.completed) {
                    if (task.rec_str) this.stats.recurring_completed++
                    else              this.stats.completed++;
                    continue;
                }

                for (proj of task.projects) {
                    n = this.stats.projects.get(proj);
                    this.stats.projects.set(proj, n ? ++n : 1);
                }

                for (context of task.contexts) {
                    n = this.stats.contexts.get(context);
                    this.stats.contexts.set(context, n ? ++n : 1);
                }

                if (task.hidden) {
                    this.stats.hidden++;
                    continue;
                }

                if (task.priority === '(_)') {
                    this.stats.no_priority++;
                } else {
                    n = this.stats.priorities.get(task.priority);
                    this.stats.priorities.set(task.priority, n ? ++n : 1);
                }

                if (task.rec_str) this.stats.recurring_incompleted++;
            }
        }


        //
        // update panel label
        //
        {
            let n_incompleted = this.tasks.length -
                                this.stats.completed -
                                this.stats.hidden -
                                this.stats.recurring_completed -
                                this.stats.deferred_tasks;

            this.panel_item.set_label('' + n_incompleted);

            if (n_incompleted) this.panel_item.actor.remove_style_class_name('done');
            else               this.panel_item.actor.add_style_class_name('done');
        }


        //
        // Since contexts/projects/priorities are filters, it can happen that we
        // have redundant filters in case tasks were deleted. Clean 'em up.
        //
        {
            let current = this.get_current_todo_file();
            let i, arr, len;

            arr = current.filters.priorities;
            for (i = 0, len = arr.length; i < len; i++) {
                if (! this.stats.priorities.has(arr[i])) {
                    arr.splice(i, 1);
                    len--; i--;
                }
            }

            arr = current.filters.contexts;
            for (i = 0, len = arr.length; i < len; i++) {
                if (! this.stats.contexts.has(arr[i])) {
                    arr.splice(i, 1);
                    len--; i--;
                }
            }

            arr = current.filters.projects;
            for (i = 0, len = arr.length; i < len; i++) {
                if (! this.stats.projects.has(arr[i])) {
                    arr.splice(i, 1);
                    len--; i--;
                }
            }
        }

        this.sort_tasks();
        this.show_view__default(true, refresh_default_view);
        if (write_to_file) this.write_tasks_to_file();

        this.emit('tasks-changed');
    }

    sort_tasks () {
        if (! this.get_current_todo_file().automatic_sort) return;

        let property_map = {
            [G.SortType.PIN]             : 'pinned',
            [G.SortType.CONTEXT]         : 'first_context',
            [G.SortType.PROJECT]         : 'first_project',
            [G.SortType.PRIORITY]        : 'priority',
            [G.SortType.COMPLETED]       : 'completed',
            [G.SortType.DUE_DATE]        : 'due_date',
            [G.SortType.ALPHABET]        : 'msg_text',
            [G.SortType.RECURRENCE]      : 'rec_next',
            [G.SortType.CREATION_DATE]   : 'creation_date',
            [G.SortType.COMPLETION_DATE] : 'completion_date',
        };

        let sort  = this.get_current_todo_file().sorts;
        let i     = 0;
        let len   = sort.length;
        let props = Array(len);

        for (; i < len; i++) {
            props[i] = property_map[ sort[i][0] ];
        }

        this.tasks.sort((a, b) => {
            let x, y;

            for (i = 0; (i < len) && (x = a[props[i]]) === (y = b[props[i]]); i++);

            if (i === len) return 0;

            switch (sort[i][0]) {
              case G.SortType.PRIORITY:
                if (sort[i][1] === G.SortOrder.DESCENDING) return +(x > y) || +(x === y) - 1;
                else                                       return +(x < y) || +(x === y) - 1;
              default:
                if (sort[i][1] === G.SortOrder.DESCENDING) return +(x < y) || +(x === y) - 1;
                else                                       return +(x > y) || +(x === y) - 1;
            }
        });
    }

    // Append the task strings of each given task to the current done.txt file.
    //
    // If a given task is not completed, it's task string will be updated to
    // show that it's completed prior to been appended to the done.txt file.
    //
    // The task objects will not be changed.
    //
    // @tasks: array (of task objects)
    archive_tasks (tasks) {
        let content = '';
        let today   = MISC_UTILS.date_yyyymmdd();

        for (let task of tasks) {
            if (task.completed) {
                content += task.task_str + '\n';
            } else if (task.priority === '(_)') {
                content += `x ${today} ${task.task_str}\n`;
            } else {
                content += `x ${today} ${task.task_str.slice(3)} pri:${task.priority[1]}\n`;
            }
        }

        try {
            let current = this.get_current_todo_file();

            if (!current || !current.done_file) return;

            let done_file     = MISC_UTILS.file_new_for_path(current.done_file);
            let append_stream = done_file.append_to(Gio.FileCreateFlags.NONE, null);

            append_stream.write_all(content, null);
        } catch (e) { logError(e); }
    }

    show_view__default (unlock = false, force_refresh = false) {
        if (unlock) this.view_manager.lock = false;
        else if (this.view_manager.lock) return;

        if (!force_refresh && this.view_manager.current_view_name === G.View.DEFAULT) {
            Mainloop.idle_add(() => this.view_manager.current_view.dummy_focus_actor.grab_key_focus());
            return;
        }

        this.view_manager.close_current_view();

        let view = new VIEW_DEFAULT.ViewDefault(this.ext, this);

        this.view_manager.show_view({
            view           : view,
            view_name      : G.View.DEFAULT,
            actors         : [view.actor],
            focused_actor  : view.dummy_focus_actor,
            close_callback : () => view.close(),
        });
    }

    show_view__time_tracker_stats (task) {
        if (! this.time_tracker) return;

        this.ext.menu.close();
        this.stats_view.open();

        if (this.time_tracker.stats_data.size === 0)
            this.stats_view.show_mode__banner(_('Loading...'));

        Mainloop.idle_add(() => {
            let stats = this.time_tracker.get_stats();

            if (!stats) {
                this.stats_view.show_mode__banner(_('Nothing found.'));
            } else if (!task) {
                this.stats_view.set_stats(...stats);
                this.stats_view.show_mode__global(MISC_UTILS.date_yyyymmdd());
            } else {
                this.stats_view.set_stats(...stats);
                let d = new Date();
                this.stats_view.show_mode__single(d.getFullYear(), d.getMonth(), task.task_str, '()');
            }
        });
    }

    show_view__loading (unlock = false) {
        if (unlock) this.view_manager.lock = false;
        else if (this.view_manager.lock) return;

        this.panel_item.set_mode('icon');
        this.panel_item.actor.remove_style_class_name('done');
        this.panel_item.icon.gicon = MISC_UTILS.getIcon('timepp-todo-loading-symbolic');

        let view = new VIEW_LOADING.ViewLoading(this.ext, this);

        this.view_manager.show_view({
            view           : view,
            view_name      : G.View.LOADING,
            actors         : [view.actor],
            focused_actor  : view.loading_msg,
            close_callback : () => {
                view.close();
                this.panel_item.icon.gicon = MISC_UTILS.getIcon('timepp-todo-symbolic');
                this._toggle_panel_item_mode();
            }
        });
    }

    show_view__search (search_str = false, unlock = false) {
        if (unlock) this.view_manager.lock = false;
        else if (this.view_manager.lock) return;

        this.view_manager.close_current_view();

        let view = new VIEW_SEARCH.ViewSearch(this.ext, this);

        this.view_manager.show_view({
            view           : view,
            view_name      : G.View.SEARCH,
            focused_actor  : view.search_entry,
            actors         : [view.actor],
            close_callback : () => view.close(),
        });

        if (search_str) view.search_entry.text = search_str;
    }

    show_view__kanban_switcher (unlock = false) {
        if (unlock) this.view_manager.lock = false;
        else if (this.view_manager.lock) return;

        let view = new VIEW_KANBAN_SWITCHER.KanbanSwitcher(this.ext, this);

        this.view_manager.show_view({
            view           : view,
            view_name      : G.View.KANBAN_SWITCHER,
            actors         : [view.actor],
            focused_actor  : view.entry,
            close_callback : () => view.close(),
        });
    }

    show_view__clear_completed (unlock = false) {
        if (unlock) this.view_manager.lock = false;
        else if (this.view_manager.lock) return;

        let view = new VIEW_CLEAR.ViewClearTasks(this.ext, this);

        this.view_manager.show_view({
            view           : view,
            view_name      : G.View.CLEAR,
            actors         : [view.actor],
            focused_actor  : view.button_cancel,
            close_callback : () => view.close(),
        });

        view.connect('delete-all', () => {
            let incompleted_tasks = [];

            for (let i = 0, len = this.tasks.length; i < len; i++) {
                if (!this.tasks[i].completed || this.tasks[i].rec_str)
                    incompleted_tasks.push(this.tasks[i]);
            }

            this.tasks = incompleted_tasks;
            this.on_tasks_changed();
        });

        view.connect('archive-all', () => {
            let completed_tasks   = [];
            let incompleted_tasks = [];

            for (let task of this.tasks) {
                if (!task.completed || task.rec_str) incompleted_tasks.push(task);
                else                                 completed_tasks.push(task);
            }

            this.archive_tasks(completed_tasks);
            this.tasks = incompleted_tasks;
            this.on_tasks_changed();
        });

        view.connect('cancel', () => {
            this.show_view__default();
        });
    }

    show_view__file_switcher (unlock = false) {
        if (unlock) this.view_manager.lock = false;
        else if (this.view_manager.lock) return;

        let view = new VIEW_FILE_SWITCHER.ViewFileSwitcher(this.ext, this);

        this.view_manager.show_view({
            view           : view,
            view_name      : G.View.FILE_SWITCH,
            actors         : [view.actor],
            focused_actor  : this.cache.todo_files.length ? view.entry : view.button_add_file,
            close_callback : () => view.close(),
        });

        if (this.cache.todo_files.length === 0) this.panel_item.set_mode('icon');

        view.connect('update', (_, files) => {
            this.cache.todo_files = files;
            this.store_cache();
            Main.panel.menuManager.ignoreRelease();
            this._init_todo_file();
        });

        view.connect('cancel', () => {
            this.show_view__default();
        });
    }

    show_view__sort (unlock = false) {
        if (unlock) this.view_manager.lock = false;
        else if (this.view_manager.lock) return;

        let view = new VIEW_SORT.ViewSort(this.ext, this);

        this.view_manager.show_view({
            view           : view,
            view_name      : G.View.SELECT_SORT,
            actors         : [view.actor],
            focused_actor  : view.button_ok,
            close_callback : () => view.close(),
        });

        view.connect('update-sort', (_, new_sort, automatic_sort) => {
            let current            = this.get_current_todo_file();
            current.sorts          = new_sort;
            current.automatic_sort = automatic_sort;

            this.sort_tasks();
            this.store_cache();
            this.show_view__default();
        });
    }

    show_view__filters (unlock = false) {
        if (unlock) this.view_manager.lock = false;
        else if (this.view_manager.lock) return;

        let view = new VIEW_FILTERS.ViewFilters(this.ext, this);

        this.view_manager.show_view({
            view           : view,
            view_name      : G.View.SELECT_FILTER,
            actors         : [view.actor],
            focused_actor  : view.entry.entry,
            close_callback : () => view.close(),
        });

        view.connect('filters-updated', (_, filters) => {
            this.get_current_todo_file().filters = filters;
            this.store_cache();
            this.show_view__default();
        });
    }

    show_view__task_editor (task, unlock = false) {
        if (unlock) this.view_manager.lock = false;
        else if (this.view_manager.lock) return;

        this.view_manager.lock = true;

        let view = new VIEW_TASK_EDITOR.ViewTaskEditor(this.ext, this, task);

        this.view_manager.show_view({
            view           : view,
            view_name      : G.View.EDITOR,
            actors         : [view.actor],
            focused_actor  : view.entry.entry,
            close_callback : () => view.close(),
        });

        if (task) this.time_tracker.stop_tracking(task);

        view.connect('delete-task', (_, do_archive) => {
            if (do_archive) this.archive_tasks([task]);

            for (let i = 0, len = this.tasks.length; i < len; i++) {
                if (this.tasks[i] === task) {
                    this.tasks.splice(i, 1);
                    break;
                }
            }

            this.on_tasks_changed();
        });

        view.connect('add-task', (_, task) => {
            this.tasks.push(task);
            this.on_tasks_changed();
        });

        view.connect('edited-task', () => {
            this.on_tasks_changed();
        });

        view.connect('cancel', () => {
            this.show_view__default(true);
        });
    }
}
Signals.addSignalMethods(SectionMain.prototype);