#!/usr/bin/env python3
###############################################################################
#
# Copyright 2006 - 2021, Tomas Babej, Paul Beckingham, Federico Hernandez.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# https://www.opensource.org/licenses/mit-license.php
#
###############################################################################

import sys
import os
import unittest
import re

# Ensure python finds the local simpletap module
sys.path.append(os.path.dirname(os.path.abspath(__file__)))

from basetest import Task, TestCase


class ContextManagementTest(TestCase):
    def setUp(self):
        self.t = Task()

    def test_context_define_confirmation(self):
        """With confirmation active, prompt if context filter matches no tasks"""
        self.t.config("confirmation", "on")

        code, out, err = self.t.runError(
            "context define work project:Work", input="y\nn\n"
        )
        self.assertIn("The filter 'project:Work' matches 0 pending tasks.", out)
        self.assertNotIn("Context 'work' defined", out)

        # Assert the config contains context definition
        self.assertNotIn("context.work=project:Work\n", self.t.taskrc_content)

    def test_context_define(self):
        """Test simple context definition."""
        code, out, err = self.t("context define work project:Work", input="y\ny\nn\n")
        self.assertIn("Context 'work' defined", out)

        # Assert the config contains read context definition
        context_line = "context.work.read=project:Work\n"
        self.assertIn(context_line, self.t.taskrc_content)

        # Assert that it contains the definition only once
        self.assertEqual(self.t.taskrc_content.count(context_line), 1)

        # Assert the config does not contain write context definition
        context_line = "context.work.write=project:Work\n"
        self.assertNotIn(context_line, self.t.taskrc_content)

        # Assert that legacy style was not used
        # Assert the config contains read context definition
        context_line = "context.work=project:Work\n"
        self.assertNotIn(context_line, self.t.taskrc_content)

    def test_context_redefine_same_definition(self):
        """Test re-defining the context with the same definition."""
        self.t("context define work project:Work", input="y\ny\ny\n")
        code, out, err = self.t("context define work project:Work", input="y\ny\ny\n")
        self.assertIn("Context 'work' defined (read, write).", out)

        # Assert the config contains context definition
        context_line = "context.work.read=project:Work\n"
        self.assertIn(context_line, self.t.taskrc_content)
        self.assertEqual(self.t.taskrc_content.count(context_line), 1)

        context_line = "context.work.write=project:Work\n"
        self.assertIn(context_line, self.t.taskrc_content)
        self.assertEqual(self.t.taskrc_content.count(context_line), 1)

    def test_context_redefine_different_definition(self):
        """Test re-defining the context with different definition."""
        self.t("context define work project:Work", input="y\ny\ny\n")
        code, out, err = self.t("context define work +work", input="y\ny\ny\n")
        self.assertIn("Context 'work' defined", out)

        # Assert the config does not contain the old context definition
        self.assertNotIn("context.work.read=project:Work\n", self.t.taskrc_content)
        self.assertNotIn("context.work.write=project:Work\n", self.t.taskrc_content)

        # Assert the config contains context definition
        context_line = "context.work.read=+work\n"
        self.assertIn(context_line, self.t.taskrc_content)
        self.assertEqual(self.t.taskrc_content.count(context_line), 1)

        context_line = "context.work.write=+work\n"
        self.assertIn(context_line, self.t.taskrc_content)
        self.assertEqual(self.t.taskrc_content.count(context_line), 1)

    def test_context_define_invalid_for_write_due_to_modifier(self):
        """Test definition of a context that is not a valid write context."""
        self.t.config("confirmation", "off")
        code, out, err = self.t("context define urgent due.before:today")
        self.assertIn("Context 'urgent' defined", out)

        # Assert the config contains read context definition
        context_line = "context.urgent.read=due.before:today\n"
        self.assertIn(context_line, self.t.taskrc_content)

        # Assert that it contains the definition only once
        self.assertEqual(self.t.taskrc_content.count(context_line), 1)

        # Assert the config does not contain write context definition
        context_line = "context.urgent.write=due.before:today\n"
        self.assertNotIn(context_line, self.t.taskrc_content)

        # Assert that the write context was not set at all
        self.assertNotIn("context.urgent.write=", self.t.taskrc_content)

        # Assert that legacy style was not used
        # Assert the config contains read context definition
        context_line = "context.urgent=due.before:today\n"
        self.assertNotIn(context_line, self.t.taskrc_content)

    def test_context_define_invalid_for_write_due_to_operator(self):
        """Test definition of a context that is not a valid write context because it uses an OR operator."""
        self.t.config("confirmation", "off")
        code, out, err = self.t("context define urgent due:today or +next")
        self.assertIn("Context 'urgent' defined", out)

        # Assert the config contains read context definition
        context_line = "context.urgent.read=due:today or +next\n"
        self.assertIn(context_line, self.t.taskrc_content)

        # Assert that it contains the definition only once
        self.assertEqual(self.t.taskrc_content.count(context_line), 1)

        # Assert the config does not contain write context definition
        context_line = "context.urgent.write=due:today or +next\n"
        self.assertNotIn(context_line, self.t.taskrc_content)

        # Assert that the write context was not set at all
        self.assertNotIn("context.urgent.write=", self.t.taskrc_content)

        # Assert that legacy style was not used
        # Assert the config contains read context definition
        context_line = "context.urgent=due:today or +next\n"
        self.assertNotIn(context_line, self.t.taskrc_content)

    def test_context_define_invalid_for_write_due_to_tag_exclusion(self):
        """Test definition of a context that is not a valid write context because it contains a tag exclusion."""
        self.t.config("confirmation", "off")
        code, out, err = self.t("context define nowork due:today -work")
        self.assertIn("Context 'nowork' defined", out)

        # Assert the config contains read context definition
        context_line = "context.nowork.read=due:today -work\n"
        self.assertIn(context_line, self.t.taskrc_content)

        # Assert that it contains the definition only once
        self.assertEqual(self.t.taskrc_content.count(context_line), 1)

        # Assert the config does not contain write context definition
        context_line = "context.nowork.write=due:today -work\n"
        self.assertNotIn(context_line, self.t.taskrc_content)

        # Assert that the write context was not set at all
        self.assertNotIn("context.nowork.write=", self.t.taskrc_content)

        # Assert that legacy style was not used
        # Assert the config contains read context definition
        context_line = "context.nowork=due:today -work\n"
        self.assertNotIn(context_line, self.t.taskrc_content)

    def test_context_delete(self):
        """Test simple context deletion."""
        self.t("context define work project:Work", input="y\ny\n")
        code, out, err = self.t("context delete work", input="y\ny\n")
        self.assertIn("Context 'work' deleted.", out)

        # Assert that taskrc does not countain context work definition
        self.assertFalse(any("context.work" in line for line in self.t.taskrc_content))

    def test_context_delete_undefined(self):
        """Test deletion of undefined context."""
        code, out, err = self.t.runError("context delete foo", input="y\n")
        self.assertIn("Context 'foo' not found.", err)

        # Assert that taskrc does not countain context work definition
        self.assertFalse(
            any("context.foo.read=" in line for line in self.t.taskrc_content)
        )
        self.assertFalse(
            any("context.foo.write=" in line for line in self.t.taskrc_content)
        )

    def test_context_delete_unset_after_removal(self):
        """Test that context is unset if its definition has been removed."""
        self.t("context define work project:Work", input="y\ny\n")
        self.t("context work")
        code, out, err = self.t("context delete work", input="y\ny\n")
        self.assertIn("Context 'work' deleted.", out)

        # Assert that taskrc does not countain context work definition
        self.assertFalse(any("context.work=" in line for line in self.t.taskrc_content))
        self.assertFalse(
            any("context.work.read=" in line for line in self.t.taskrc_content)
        )
        self.assertFalse(
            any("context.work.write=" in line for line in self.t.taskrc_content)
        )

        # Aseert that the context is not set
        code, out, err = self.t("context show")
        self.assertIn("No context is currently applied.", out)
        self.assertFalse(
            any(
                re.search(r"^context(\.(read|write))?=", line)
                for line in self.t.taskrc_content
            )
        )

    def test_context_list_active(self):
        """Test the 'context list' command."""
        self.t("context define work project:Work", input="y\ny\n")
        self.t("context define home +home", input="y\ny\n")
        self.t("context home")
        code, out, err = self.t("context list")
        contains_work = (
            lambda line: "work" in line and "project:Work" in line and "no" in line
        )
        contains_home = (
            lambda line: "home" in line and "+home" in line and "yes" in line
        )

        # Assert that output contains work and home context definitions exactly
        # once
        self.assertEqual(len(list(filter(contains_work, out.splitlines()))), 1)
        self.assertEqual(len(list(filter(contains_home, out.splitlines()))), 1)

    def test_context_list_legacy(self):
        """Test the determination of legacy context definition."""
        self.t("config context.old project:Old", input="y\n")
        self.t("context old")
        code, out, err = self.t("context list")

        # Assert that "old" context has only the read component defined
        self.assertRegex(out, r"read\s+project:Old\s+yes")
        self.assertRegex(out, r"write\s+yes")

    def test_context_initially_empty(self):
        """Test that no context is set initially."""
        self.t("context define work project:Work", input="y\ny\n")
        self.t("context define home +home", input="y\ny\n")

        code, out, err = self.t("context show")
        self.assertIn("No context is currently applied.", out)
        self.assertFalse(
            any(re.search("^context=", line) for line in self.t.taskrc_content)
        )

    def test_context_setting(self):
        """Test simple context setting."""
        self.t("context define work project:Work", input="y\ny\n")
        self.t("context define home home", input="y\ny\n")

        code, out, err = self.t("context home")
        self.assertIn("Context 'home' set.", out)
        self.assertIn("context=home\n", self.t.taskrc_content)

    def test_context_resetting(self):
        """Test resetting the same context."""
        self.t("context define work project:Work", input="y\ny\n")
        self.t("context define home +home", input="y\ny\n")

        self.t("context home")
        code, out, err = self.t("context home")
        self.assertIn("Context 'home' set.", out)

        context_line = "context=home\n"
        self.assertEqual(self.t.taskrc_content.count(context_line), 1)

    def test_context_switching(self):
        """Test changing the context."""
        self.t("context define work project:Work", input="y\ny\n")
        self.t("context define home +home", input="y\ny\n")

        # Switch to home context
        code, out, err = self.t("context home")
        self.assertIn("Context 'home' set.", out)
        self.assertEqual(self.t.taskrc_content.count("context=home\n"), 1)

        # Switch to work context
        code, out, err = self.t("context work")
        self.assertIn("Context 'work' set.", out)
        self.assertNotIn("context=home\n", self.t.taskrc_content)
        self.assertEqual(self.t.taskrc_content.count("context=work\n"), 1)

        # Switch back to home context
        code, out, err = self.t("context home")
        self.assertIn("Context 'home' set.", out)
        self.assertNotIn("context=work\n", self.t.taskrc_content)
        self.assertEqual(self.t.taskrc_content.count("context=home\n"), 1)

    def test_context_unsetting(self):
        """Test removing the context."""
        self.t("context define work project:Work", input="y\ny\n")
        self.t("context define home +home", input="y\ny\n")

        self.t("context home")
        code, out, err = self.t("context none")

        # Assert expected output.
        self.assertIn("Context unset.", out)

        # Assert no context definition in the taskrc
        contains_any_context = lambda line: re.match("^context=", line)
        self.assertFalse(
            any(contains_any_context(line) for line in self.t.taskrc_content)
        )

        # Assert no context showing up using show subcommand
        code, out, err = self.t("context show")
        self.assertIn("No context is currently applied.", out)

    def test_context_unsetting_after_switching(self):
        """Test unsetting the context after changing the context around."""
        self.t("context define work project:Work", input="y\ny\n")
        self.t("context define home +home", input="y\ny\n")

        # Switch to contexts around
        self.t("context home")
        self.t("context work")
        self.t("context home")

        # Unset the context
        code, out, err = self.t("context none")

        # Assert expected output.
        self.assertIn("Context unset.", out)

        # Assert no context definition in the taskrc
        contains_any_context = lambda line: re.match("^context=", line)
        self.assertFalse(
            any(contains_any_context(line) for line in self.t.taskrc_content)
        )

        # Assert no context showing up using show subcommand
        code, out, err = self.t("context show")
        self.assertIn("No context is currently applied.", out)

    def test_context_unsetting_with_no_context_set(self):
        """Test removing the context when no context is set."""
        self.t("context define work project:Work", input="y\ny\n")
        self.t("context define home +home", input="y\ny\n")

        code, out, err = self.t.runError("context none")

        # Assert expected output.
        self.assertIn("Context not unset.", err)

        # Assert no context definition in the taskrc
        contains_any_context = lambda line: re.match("^context=", line)
        self.assertFalse(
            any(contains_any_context(line) for line in self.t.taskrc_content)
        )

        # Assert no context showing up using show subcommand
        code, out, err = self.t("context show")
        self.assertIn("No context is currently applied.", out)

    def test_context(self):
        """Test the _context command."""
        self.t("context define work project:Work", input="y\ny\n")
        self.t("context define home +home", input="y\ny\n")
        code, out, err = self.t("_context")

        # Assert expected output.
        self.assertIn("work", out.splitlines())
        self.assertIn("home", out.splitlines())
        self.assertEqual(len(out.splitlines()), 2)

    def test_context_completion(self):
        """Test the _context command with some context set."""
        self.t("context define work project:Work", input="y\ny\n")
        self.t("context define home +home", input="y\ny\n")

        # Activate some context
        self.t("context work")
        code, out, err = self.t("_context")

        # Assert expected output.
        self.assertIn("work", out.splitlines())
        self.assertIn("home", out.splitlines())
        self.assertEqual(len(out.splitlines()), 2)


class ContextEvaluationTest(TestCase):
    def setUp(self):
        self.t = Task()

        self.t.config("confirmation", "off")

        # Setup contexts
        self.t("context define work project:Work")
        self.t("context define home +home")
        self.t("context define today due:today")

        # Setup tasks
        self.t('add project:Work "work task"')
        self.t('add +home "home task"')
        self.t('add project:Work due:today "work today task"')
        self.t('add +home due:today "home today task"')

    def test_context_evaluation(self):
        """Test the context applied with report list command."""
        code, out, err = self.t("list")

        # Assert all the tasks are present in the output
        self.assertIn("work task", out)
        self.assertIn("home task", out)
        self.assertIn("work today task", out)
        self.assertIn("home today task", out)

        # Set the home context and rerun the report
        self.t("context home")
        code, out, err = self.t("list")

        # Assert all the tasks with the home tag are present in the output
        self.assertNotIn("work task", out)
        self.assertIn("home task", out)
        self.assertNotIn("work today task", out)
        self.assertIn("home today task", out)

    def test_context_evaluation_switching(self):
        """Test swtiching context using the list report."""
        code, out, err = self.t("list")

        # Assert all the tasks are present in the output
        self.assertIn("work task", out)
        self.assertIn("home task", out)
        self.assertIn("work today task", out)
        self.assertIn("home today task", out)

        # Set the home context and rerun the report
        self.t("context home")
        code, out, err = self.t("list")

        # Assert all the tasks with the home tag are present in the output
        self.assertNotIn("work task", out)
        self.assertIn("home task", out)
        self.assertNotIn("work today task", out)
        self.assertIn("home today task", out)

        # Set the work context and rerun the report
        self.t("context work")
        code, out, err = self.t("list")

        # Assert all the tasks with the home tag are present in the output
        self.assertIn("work task", out)
        self.assertNotIn("home task", out)
        self.assertIn("work today task", out)
        self.assertNotIn("home today task", out)

        # Set the today context and rerun the report
        self.t("context today")
        code, out, err = self.t("list")

        # Assert all the tasks with the home tag are present in the output
        self.assertNotIn("work task", out)
        self.assertNotIn("home task", out)
        self.assertIn("work today task", out)
        self.assertIn("home today task", out)

    def test_context_evaluation_unset(self):
        """Test unsetting context with report list command."""
        self.t("context home")
        code, out, err = self.t("list")

        # Assert all the tasks home tagged tasks are present
        self.assertNotIn("work task", out)
        self.assertIn("home task", out)
        self.assertNotIn("work today task", out)
        self.assertIn("home today task", out)

        # Set the context to none
        self.t("context none")
        code, out, err = self.t("list")

        # Assert all the tasks are present in the output
        self.assertIn("work task", out)
        self.assertIn("home task", out)
        self.assertIn("work today task", out)
        self.assertIn("home today task", out)

    def test_context_evaluation_with_user_filters(self):
        """Test the context applied with report list command combined with user filters."""

        # Set the home context
        self.t("context home")
        code, out, err = self.t("list due:today")

        # Assert all the tasks are present in the output
        self.assertNotIn("work task", out)
        self.assertNotIn("home task", out)
        self.assertNotIn("work today task", out)
        self.assertIn("home today task", out)

        # Set the work context and rerun the report
        self.t("context work")
        code, out, err = self.t("list due:today")

        # Assert all the tasks are present in the output
        self.assertNotIn("work task", out)
        self.assertNotIn("home task", out)
        self.assertIn("work today task", out)
        self.assertNotIn("home today task", out)

    def test_context_not_applied_on_id_filters(self):
        """
        Test that context is not applied when explicit ID
        filters are used.
        """

        self.t("context home")

        # Try task not included in context
        output = self.t("1 list")[1]

        # Assert that ID filter works even if it does not match the context
        self.assertIn("work task", output)
        self.assertNotIn("home task", output)
        self.assertNotIn("work today task", output)
        self.assertNotIn("home today task", output)

        # Try task included in context
        output = self.t("2 list")[1]

        # Assert that ID filter works if it does match
        # the context (sanity check)
        self.assertNotIn("work task", output)
        self.assertIn("home task", output)
        self.assertNotIn("work today task", output)
        self.assertNotIn("home today task", output)

        # Test for combination of IDs
        output = self.t("1 2 list")[1]

        # Assert that ID filter works if it partly matches
        # and partly does not match the context
        self.assertIn("work task", output)
        self.assertIn("home task", output)
        self.assertNotIn("work today task", output)
        self.assertNotIn("home today task", output)

    def test_context_not_applied_on_uuid_filters(self):
        """
        Test that context is not applied when explicit UUID
        filters are used.
        """

        self.t("context home")
        first_uuid = self.t("_get 1.uuid")[1]
        second_uuid = self.t("_get 2.uuid")[1]

        # Try task not included in context
        output = self.t("%s list" % first_uuid)[1]

        # Assert that UUID filter works even if it does not match
        # the context
        self.assertIn("work task", output)
        self.assertNotIn("home task", output)
        self.assertNotIn("work today task", output)
        self.assertNotIn("home today task", output)

        # Try task included in context
        output = self.t("%s list" % second_uuid)[1]

        # Assert that UUID filter works if it does match
        # the context (sanity check)
        self.assertNotIn("work task", output)
        self.assertIn("home task", output)
        self.assertNotIn("work today task", output)
        self.assertNotIn("home today task", output)

        # Test for combination of UUIDs
        output = self.t("%s %s list" % (first_uuid, second_uuid))[1]

        # Assert that UUID filter works if it partly matches
        # and partly does not match the context
        self.assertIn("work task", output)
        self.assertIn("home task", output)
        self.assertNotIn("work today task", output)
        self.assertNotIn("home today task", output)

    def test_context_ignored(self):
        """Test the context is not applied with report list command if
        report.list.context is set to 0."""

        # Turn off context for this report
        self.t.config("report.list.context", "0")

        # Get the tasks
        code, out, err = self.t("list")

        # Assert all the tasks are present in the output
        self.assertIn("work task", out)
        self.assertIn("home task", out)
        self.assertIn("work today task", out)
        self.assertIn("home today task", out)

        # Set the home context and rerun the report
        self.t("context home")

        code, out, err = self.t("list")

        # Assert nothing changed - all the tasks are present in the output
        self.assertIn("work task", out)
        self.assertIn("home task", out)
        self.assertIn("work today task", out)
        self.assertIn("home today task", out)


class ContextErrorHandling(TestCase):
    def setUp(self):
        self.t = Task()

    def test_list_empty(self):
        """Verify 'task context list' with no contexts yields error"""
        code, out, err = self.t.runError("context list")
        self.assertIn("No contexts defined.", err)

    def test_define_empty(self):
        """Verify 'task context define' with no contexts yields error"""
        code, out, err = self.t.runError("context define")
        self.assertIn("Both context name and its definition must be provided.", err)

    def test_delete_empty(self):
        """Verify 'task context delete' with no contexts yields error"""
        code, out, err = self.t.runError("context delete")
        self.assertIn("Context name needs to be specified.", err)

    def test_set_missing(self):
        """Verify 'task context missing' with no contexts yields error"""
        code, out, err = self.t.runError("context missing")
        self.assertIn("Context 'missing' not found.", err)

    def test_set_multi(self):
        """Verify 'task context one\\ two' with no contexts yields error"""
        code, out, err = self.t.runError("context one\\ two")
        self.assertIn("Context 'one two' not found.", err)

    def test_show_missing(self):
        """Verify 'task context show' with no contexts yields correct information"""
        code, out, err = self.t("context show")
        self.assertIn("No context is currently applied.", out)

    def test_show_present(self):
        """Verify 'task context show' with contexts works"""
        self.t.config("confirmation", "off")
        code, out, err = self.t("context define work +work")
        self.assertIn(
            "Context 'work' defined (read, write). Use 'task context work' to activate.",
            out,
        )

        code, out, err = self.t("context work")
        self.assertIn("Context 'work' set. Use 'task context none' to remove.", out)

        code, out, err = self.t("context show")
        self.assertIn("Context 'work' with", out)
        self.assertIn("read filter: '+work'", out)
        self.assertIn("write filter: '+work'", out)
        self.assertIn("is currently applied", out)

        code, out, err = self.t("context none")
        self.assertIn("Context unset.", out)

        code, out, err = self.t("context show")
        self.assertIn("No context is currently applied.", out)


class TestBug1734(TestCase):
    def setUp(self):
        self.t = Task()
        self.t("add zero")
        self.t("add one +tag")
        self.t("context define foo +tag", input="y\nn\n")

    def test_calendar(self):
        """The 'calendar' command should not fail when a context is active"""
        code, out, err = self.t("calendar")


# TODO Prove context does not interfere with export
# TODO Prove context does not interfere with undo
# TODO Prove context does not interfere with helper commands


if __name__ == "__main__":
    from simpletap import TAPTestRunner

    unittest.main(testRunner=TAPTestRunner())

# vim: ai sts=4 et sw=4 ft=python syntax=python