# Standard library imports
import datetime as dt
import unittest

# PyQt imports


# Third party imports

# App imports
from app.models import (
    db,
    Playdates,
    Tracks,
)
from classes import (
    Filter,
)


class MyTestCase(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        """Runs once before any test in this class"""

        db.create_all()

        with db.Session() as session:
            # Create some track entries
            _ = Tracks(**dict(
                session=session,
                artist="a",
                bitrate=0,
                duration=100,
                fade_at=0,
                path="/alpha/bravo/charlie",
                silence_at=0,
                start_gap=0,
                title="abc"
            ))
            track2 = Tracks(**dict(
                session=session,
                artist="a",
                bitrate=0,
                duration=100,
                fade_at=0,
                path="/xray/yankee/zulu",
                silence_at=0,
                start_gap=0,
                title="xyz"
            ))
            track2_id = track2.id
            # Add playdates
            # Track 2 played just over a year ago
            just_over_a_year_ago = dt.datetime.now() - dt.timedelta(days=367)
            _ = Playdates(session, track2_id, when=just_over_a_year_ago)

    @classmethod
    def tearDownClass(cls):
        """Runs once after all tests"""

        db.drop_all()

    def setUp(self):
        """Runs before each test"""

        pass

    def tearDown(self):
        """Runs after each test"""

        pass

    def test_search_path_1(self):
        """Search for unplayed track"""

        filter = Filter(path="alpha", last_played_comparator="never")

        with db.Session() as session:
            results = Tracks.get_filtered_tracks(session, filter)
            assert len(results) == 1
            assert 'alpha' in results[0].path

    def test_search_path_2(self):
        """Search for unplayed track that doesn't exist"""

        filter = Filter(path="xray", last_played_comparator="never")

        with db.Session() as session:
            results = Tracks.get_filtered_tracks(session, filter)
            assert len(results) == 0

    def test_played_over_a_year_ago(self):
        """Search for tracks played over a year ago"""

        filter = Filter(last_played_unit="years", last_played_number=1)

        with db.Session() as session:
            results = Tracks.get_filtered_tracks(session, filter)
            assert len(results) == 1
            assert 'zulu' in results[0].path

    def test_played_over_two_years_ago(self):
        """Search for tracks played over 2 years ago"""

        filter = Filter(last_played_unit="years", last_played_number=2)

        with db.Session() as session:
            results = Tracks.get_filtered_tracks(session, filter)
            assert len(results) == 0

    def test_never_played(self):
        """Search for tracks never played"""

        filter = Filter(last_played_comparator="never")

        with db.Session() as session:
            results = Tracks.get_filtered_tracks(session, filter)
            assert len(results) == 1
            assert 'alpha' in results[0].path

    def test_played_anytime(self):
        """Search for tracks played over a year ago"""

        filter = Filter(last_played_comparator="Any time")

        with db.Session() as session:
            results = Tracks.get_filtered_tracks(session, filter)
            assert len(results) == 1
            assert 'zulu' in results[0].path