# Copyright 2019 The GNOME Music developers
#
# GNOME Music 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 2 of the License, or
# (at your option) any later version.
#
# GNOME Music 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 GNOME Music; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# The GNOME Music authors hereby grant permission for non-GPL compatible
# GStreamer plugins to be used and distributed together with GStreamer
# and GNOME Music.  This permission is above and beyond the permissions
# granted by the GPL license by which GNOME Music is covered.  If you
# modify this code, you may extend this exception to your version of the
# code, but you are not obligated to do so.  If you do not wish to do so,
# delete this exception statement from your version.

from __future__ import annotations
from typing import Any, Optional, Union
import typing

from gi.repository import GLib, GObject, Gio, Gtk

from gnomemusic.corealbum import CoreAlbum
from gnomemusic.coreartist import CoreArtist
from gnomemusic.coresong import CoreSong
from gnomemusic.grilowrappers.grltrackerplaylists import Playlist
from gnomemusic.player import PlayerPlaylist
from gnomemusic.widgets.songwidget import SongWidget
if typing.TYPE_CHECKING:
    from gnomemusic.application import Application
    from gnomemusic.search import Search
import gnomemusic.utils as utils


class CoreModel(GObject.GObject):
    """Provides all the global list models used in Music

    Music is using a hierarchy of data objects with list models to
    contain the information about the users available music. This
    hierarchy is filled mainly through Grilo, with the exception of
    playlists which are a Tracker only feature.

    There are three main models: one for artists, one for albums and
    one for songs. The data objects within these are CoreArtist,
    CoreAlbum and CoreSong respectively. These models are flattened
    list models filled by the wrappers.

    The object hierarchy is as follows.

    CoreArtist -> CoreAlbum -> CoreDisc -> CoreSong

    Playlists are a Tracker only feature and do not use the three
    main models directly.

    GrlTrackerPlaylists -> Playlist -> CoreSong

    The Player playlist is a copy of the relevant playlist, built by
    using the components described above as needed.
    """

    __gsignals__ = {
        "playlist-loaded": (GObject.SignalFlags.RUN_FIRST, None, (int,)),
        "smart-playlist-change": (GObject.SignalFlags.RUN_FIRST, None, ())
    }

    songs_available = GObject.Property(type=bool, default=False)

    _recent_size = 21

    def __init__(self, application: Application) -> None:
        """Initiate the CoreModel object

        :param Application application: The Application instance to use
        """
        super().__init__()

        self._application = application
        self._flatten_model: Optional[Gtk.FlattenListModel] = None
        self._player_signal_id = 0
        self._current_playlist_model: Optional[Union[
            Gtk.FlattenListModel, Gtk.SortListModel, Gio.ListModel]] = None
        self._previous_playlist_model: Optional[Union[
            Gtk.FlattenListModel, Gtk.SortListModel, Gio.ListModel]] = None

        self._songs_model_proxy: Gio.ListStore = Gio.ListStore.new(
            Gio.ListModel)
        self._flatten_songs_model = Gtk.FlattenListModel.new(
            self._songs_model_proxy)
        self._songs_model = Gtk.SortListModel.new(self._flatten_songs_model)
        sorter = Gtk.CustomSorter()
        sorter.set_sort_func(self._songs_sort)
        self._songs_model.props.incremental = True
        self._songs_model.set_sorter(sorter)

        self._albums_model_proxy: Gio.ListStore = Gio.ListStore.new(
            Gio.ListModel)
        self._albums_model: Gtk.FlattenListModel = Gtk.FlattenListModel.new(
            self._albums_model_proxy)
        album_sort_exp = Gtk.PropertyExpression.new(CoreAlbum, None, "title")
        albums_sorter = Gtk.StringSorter.new(album_sort_exp)
        self._albums_model_sort: Gtk.SortListModel = Gtk.SortListModel.new(
            self._albums_model, albums_sorter)

        self._artists_model_proxy: Gio.ListStore = Gio.ListStore.new(
            Gio.ListModel)
        self._artists_model: Gtk.FlattenListModel = Gtk.FlattenListModel.new(
            self._artists_model_proxy)
        artists_sort_exp = Gtk.PropertyExpression.new(
            CoreArtist, None, "artist")
        artists_sorter = Gtk.StringSorter.new(artists_sort_exp)
        self._artists_model_sort: Gtk.SortListModel = Gtk.SortListModel.new(
            self._artists_model, artists_sorter)

        self._playlist_model: Gio.ListStore = Gio.ListStore.new(CoreSong)
        self._playlist_model_sort: Gtk.SortListModel = Gtk.SortListModel.new(
            self._playlist_model)
        self._playlist_model_recent: Gtk.SliceListModel = (
            Gtk.SliceListModel.new(
                self._playlist_model_sort, 0, self._recent_size))
        self._active_core_object: Optional[Union[
            CoreAlbum, CoreArtist, Playlist]] = None

        self._songs_search_proxy: Gio.ListStore = Gio.ListStore.new(
            Gtk.FilterListModel)
        self._songs_search_flatten: Gtk.FlattenListModel = (
            Gtk.FlattenListModel())
        self._songs_search_flatten.set_model(self._songs_search_proxy)

        self._albums_search_proxy: Gio.Liststore = Gio.ListStore.new(
            Gtk.FilterListModel)
        self._albums_search_flatten: Gtk.FlattenListModel = (
            Gtk.FlattenListModel())
        self._albums_search_flatten.set_model(self._albums_search_proxy)
        self._albums_search_filter: Gtk.FilterListModel = (
            Gtk.FilterListModel.new(Gtk.AnyFilter()))

        self._artists_search_proxy: Gio.Liststore = Gio.ListStore.new(
            Gtk.FilterListModel)
        self._artists_search_flatten: Gtk.FlattenListModel = (
            Gtk.FlattenListModel())
        self._artists_search_flatten.set_model(self._artists_search_proxy)
        self._artists_search_filter: Gtk.FilterListModel = (
            Gtk.FilterListModel.new(Gtk.AnyFilter()))

        self._playlists_model: Gio.ListStore = Gio.ListStore.new(Playlist)
        self._playlists_model_filter: Gtk.FilterListModel = (
            Gtk.FilterListModel.new(self._playlists_model))
        self._playlists_model_sort: Gtk.SortListModel = Gtk.SortListModel.new(
            self._playlists_model_filter)
        playlists_sorter = Gtk.CustomSorter()
        playlists_sorter.set_sort_func(self._playlists_sort)
        self._playlists_model_sort.set_sorter(playlists_sorter)

        self._user_playlists_model_filter: Gtk.FilterListModel = (
            Gtk.FilterListModel.new(self._playlists_model))
        self._user_playlists_model_sort: Gtk.SortListModel = (
            Gtk.SortListModel.new(self._user_playlists_model_filter))
        user_playlists_sorter = Gtk.CustomSorter()
        user_playlists_sorter.set_sort_func(self._playlists_sort)
        self._user_playlists_model_sort.set_sorter(user_playlists_sorter)

        self._search: Search = application.props.search

        self._songs_model.connect(
            "items-changed", self._on_songs_items_changed)

    def _on_songs_items_changed(self, model, position, removed, added):
        available = self.props.songs_available
        now_available = model.get_n_items() > 0

        if available == now_available:
            return

        if model.get_n_items() > 0:
            self.props.songs_available = True
        else:
            self.props.songs_available = False

    def _songs_sort(
            self, song_a: CoreSong, song_b: CoreSong, data: Any = None) -> int:
        title_a = song_a.props.title
        title_b = song_b.props.title
        song_cmp = (utils.normalize_caseless(title_a)
                    == utils.normalize_caseless(title_b))
        if not song_cmp:
            return utils.natural_sort_names(title_a, title_b)

        artist_a = song_a.props.artist
        artist_b = song_b.props.artist
        artist_cmp = (utils.normalize_caseless(artist_a)
                      == utils.normalize_caseless(artist_b))
        if not artist_cmp:
            return utils.natural_sort_names(artist_a, artist_b)

        return utils.natural_sort_names(song_a.props.album, song_b.props.album)

    def _playlists_sort(self, playlist_a, playlist_b, data=None):
        if playlist_a.props.is_smart:
            if not playlist_b.props.is_smart:
                return Gtk.Ordering.SMALLER
            return utils.natural_sort_names(
                playlist_a.props.title, playlist_b.props.title)

        if playlist_b.props.is_smart:
            return Gtk.Ordering.LARGER

        date_compare = GLib.DateTime.compare(
            playlist_b.props.creation_date, playlist_a.props.creation_date)
        if date_compare == -1:
            return Gtk.Ordering.SMALLER
        elif date_compare == 1:
            return Gtk.Ordering.LARGER
        else:
            return Gtk.Ordering.EQUAL

    def _set_player_model(self, playlist_type, model):
        """Set the model for PlayerPlaylist to use

        This fills playlist model based on the playlist type and model
        given. This builds a separate model to stay alive and play
        while the user navigates other views.

        :param PlaylistType playlist_type: The type of the playlist
        :param Gio.ListStore model: The base model for the player model
        """
        if model is self._previous_playlist_model:
            for song in self._playlist_model:
                if song.props.state == SongWidget.State.PLAYING:
                    song.props.state = SongWidget.State.PLAYED

            self.emit("playlist-loaded", playlist_type)
            return

        def _bind_song_properties(model_song, player_song):
            model_song.bind_property(
                "state", player_song, "state",
                GObject.BindingFlags.BIDIRECTIONAL
                | GObject.BindingFlags.SYNC_CREATE)

        def _on_items_changed(model, position, removed, added):
            songs_list = []
            if added > 0:
                for i in list(range(added)):
                    coresong = model[position + i]
                    song = CoreSong(self._application, coresong.props.media)
                    _bind_song_properties(coresong, song)
                    songs_list.append(song)

            self._playlist_model.splice(position, removed, songs_list)

        played_states = [SongWidget.State.PLAYING, SongWidget.State.PLAYED]
        for song in self._playlist_model:
            if song.props.state in played_states:
                song.props.state = SongWidget.State.UNPLAYED

        if self._player_signal_id != 0:
            self._current_playlist_model.disconnect(self._player_signal_id)
            self._player_signal_id = 0
            self._current_playlist_model = None

        songs_added = []

        if playlist_type == PlayerPlaylist.Type.ALBUM:
            proxy_model = Gio.ListStore.new(Gio.ListModel)

            for disc in model:
                proxy_model.append(disc.props.model)

            self._flatten_model = Gtk.FlattenListModel.new(proxy_model)
            self._current_playlist_model = self._flatten_model

            for model_song in self._flatten_model:
                song = CoreSong(self._application, model_song.props.media)
                _bind_song_properties(model_song, song)
                songs_added.append(song)

        elif playlist_type == PlayerPlaylist.Type.ARTIST:
            proxy_model = Gio.ListStore.new(Gio.ListModel)

            for artist_album in model:
                for disc in artist_album.model:
                    proxy_model.append(disc.props.model)

            self._flatten_model = Gtk.FlattenListModel.new(proxy_model)
            self._current_playlist_model = self._flatten_model

            for model_song in self._flatten_model:
                song = CoreSong(self._application, model_song.props.media)
                _bind_song_properties(model_song, song)
                songs_added.append(song)

        elif playlist_type == PlayerPlaylist.Type.SONGS:
            self._current_playlist_model = self._songs_model

            for song in self._songs_model:
                songs_added.append(song)

                if song.props.state == SongWidget.State.PLAYING:
                    song.props.state = SongWidget.State.PLAYED

        elif playlist_type == PlayerPlaylist.Type.SEARCH_RESULT:
            self._current_playlist_model = self._songs_search_flatten

            for song in self._songs_search_flatten:
                songs_added.append(song)

        elif playlist_type == PlayerPlaylist.Type.PLAYLIST:
            self._current_playlist_model = model

            for model_song in model:
                song = CoreSong(self._application, model_song.props.media)
                _bind_song_properties(model_song, song)
                songs_added.append(song)

        self._playlist_model.splice(
            0, self._playlist_model.get_n_items(), songs_added)

        if self._current_playlist_model is not None:
            self._player_signal_id = self._current_playlist_model.connect(
                "items-changed", _on_items_changed)
        self._previous_playlist_model = model

        self.emit("playlist-loaded", playlist_type)

    @GObject.Property(default=None)
    def active_core_object(self):
        """Get the current playing core object
        (album, artist, playlist, search result or song).

        :returns: current media
        :rtype: CoreObject
        """
        return self._active_core_object

    @active_core_object.setter  # type: ignore
    def active_core_object(self, value):
        """Set the current playing core object
        (album, artist, playlist, search result or song).

        :param CoreObject value: new core object to play
        """
        self._active_core_object = value
        if isinstance(value, CoreAlbum):
            playlist_type = PlayerPlaylist.Type.ALBUM
            model = value.props.model
        elif isinstance(value, CoreArtist):
            playlist_type = PlayerPlaylist.Type.ARTIST
            model = value.props.model
        elif isinstance(value, Playlist):
            playlist_type = PlayerPlaylist.Type.PLAYLIST
            model = value.props.model
        # If the search is active, it means that the search view is visible,
        # so the player playlist is a list of songs from the search result.
        # Otherwise, it's a list of songs from the songs view.
        elif self._search.props.search_mode_active:
            playlist_type = PlayerPlaylist.Type.SEARCH_RESULT
            model = self._songs_search_flatten
        else:
            playlist_type = PlayerPlaylist.Type.SONGS
            model = self._songs_model

        self._set_player_model(playlist_type, model)

    @GObject.Property(
        type=Gio.ListStore, default=None, flags=GObject.ParamFlags.READABLE)
    def songs(self):
        return self._songs_model

    @GObject.Property(
        type=Gtk.FlattenListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def songs_proxy(self):
        return self._songs_model_proxy

    @GObject.Property(
        type=Gio.ListStore, default=None, flags=GObject.ParamFlags.READABLE)
    def albums(self):
        return self._albums_model

    @GObject.Property(
        type=Gtk.FlattenListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def albums_proxy(self):
        return self._albums_model_proxy

    @GObject.Property(
        type=Gio.ListStore, default=None, flags=GObject.ParamFlags.READABLE)
    def artists(self):
        return self._artists_model

    @GObject.Property(
        type=Gtk.FlattenListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def artists_proxy(self):
        return self._artists_model_proxy

    @GObject.Property(
        type=Gio.ListStore, default=None, flags=GObject.ParamFlags.READABLE)
    def playlist(self):
        return self._playlist_model

    @GObject.Property(
        type=Gtk.SortListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def albums_sort(self):
        return self._albums_model_sort

    @GObject.Property(
        type=Gtk.SortListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def artists_sort(self):
        return self._artists_model_sort

    @GObject.Property(
        type=Gtk.SortListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def playlist_sort(self):
        return self._playlist_model_sort

    @GObject.Property(
        type=Gtk.SliceListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def recent_playlist(self):
        return self._playlist_model_recent

    @GObject.Property(
        type=int, default=None,
        flags=GObject.ParamFlags.READABLE)
    def recent_playlist_size(self):
        return self._recent_size // 2

    @GObject.Property(
        type=Gtk.FilterListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def songs_search(self):
        return self._songs_search_flatten

    @GObject.Property(
        type=Gio.ListStore, default=None,
        flags=GObject.ParamFlags.READABLE)
    def songs_search_proxy(self):
        return self._songs_search_proxy

    @GObject.Property(
        type=Gtk.FlattenListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def albums_search(self) -> Gtk.FlattenListModel:
        return self._albums_search_flatten

    @GObject.Property(
        type=Gtk.FilterListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def albums_search_filter(self):
        return self._albums_search_filter

    @GObject.Property(
        type=Gio.ListStore, default=None, flags=GObject.ParamFlags.READABLE)
    def albums_search_proxy(self) -> Gio.ListStore:
        return self._albums_search_proxy

    @GObject.Property(
        type=Gtk.FlattenListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def artists_search(self) -> Gtk.FlattenListModel:
        return self._artists_search_flatten

    @GObject.Property(
        type=Gtk.FilterListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def artists_search_filter(self):
        return self._artists_search_filter

    @GObject.Property(
        type=Gio.ListStore, default=None, flags=GObject.ParamFlags.READABLE)
    def artists_search_proxy(self) -> Gio.ListStore:
        return self._artists_search_proxy

    @GObject.Property(
        type=Gio.ListStore, default=None, flags=GObject.ParamFlags.READABLE)
    def playlists(self):
        return self._playlists_model

    @GObject.Property(
        type=Gtk.SortListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def playlists_sort(self):
        return self._playlists_model_sort

    @GObject.Property(
        type=Gtk.SortListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def playlists_filter(self):
        return self._playlists_model_filter

    @GObject.Property(
        type=Gtk.SortListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def user_playlists_sort(self):
        return self._user_playlists_model_sort

    @GObject.Property(
        type=Gtk.SortListModel, default=None,
        flags=GObject.ParamFlags.READABLE)
    def user_playlists_filter(self):
        return self._user_playlists_model_filter
