using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MovieCatalogWebAPI.Models
{
    public class MoviesRepository : IMoviesRepository
    {
        //MovieDatabaseEntities db = new MovieDatabaseEntities();
        //private List<Movie> movies = new List<Movie>();
        //{
        //    new Movie{MovieID = 1, Movie_Name = "Film1", File_Name = "F1", LikeOrDislike = "Favourite", Path = "AnyPath"},
        //    new Movie{MovieID = 2, Movie_Name = "Film2", File_Name = "F2", LikeOrDislike = "Hated", Path = "AnyPath1"},
        //    new Movie{MovieID = 3, Movie_Name = "Film3", File_Name = "F3", LikeOrDislike = "", Path = "AnyPath2"}
        //};

        #region Convert Functions

        /// <summary>
        /// Converts MainMovieList element into Movie element
        /// </summary>
        /// <param name="mml">MainMovieList element that will be converted</param>
        /// <param name="UserID">Current user id</param>
        /// <returns>Convertion result (Movie element)</returns>
        public Movie ConvertMainMovieListToMovie(MainMovieList mml, int UserID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            List<Movie> list = new List<Movie>();

            //if the MainMovieList was in database && user exists
            foreach (Favourite_Hated m in db.Favourite_Hated)
            {
                if (m.UserID == UserID)
                {
                    if (m.FilmID == mml.ID)
                    {
                        Movie mov = new Movie(m.FilmID, m.Movie_Name, mml.File_Name, m.LikeOrDislike, mml.File_Path);
                        return mov;
                    }
                }
            }
            //If the MainMovieList was not added to database
            Movie mov1 = new Movie(mml.ID, " ", mml.File_Name, -1, mml.File_Path);

            return mov1;
        }

        /// <summary>
        /// Converts Movie element to MainMovieList element
        /// </summary>
        /// <param name="mov">Movie element that will be converted</param>
        /// <param name="UserID">Current User's id</param>
        /// <returns>Convertion result (MainMovieList element)</returns>
        public MainMovieList ConvertMovieToMainMovieList(Movie mov, int UserID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            MainMovieList mml = new MainMovieList();
            mml.ID = mov.MovieID;
            mml.File_Name = mov.File_Name;
            mml.File_Path = mov.Path;

            return mml;
        }

        /// <summary>
        /// Converts Movie element to Favourite_Hated element
        /// </summary>
        /// <param name="mov">Movie element that will be converted</param>
        /// <param name="UserID">Current User's id</param>
        /// <returns>Convertion result (Favourite_Hated element)</returns>
        public Favourite_Hated ConvertMovieToFavourite_Hated(Movie mov, int UserID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            Favourite_Hated fh = new Favourite_Hated();
            fh.FilmID = mov.MovieID;
            fh.UserID = UserID;
            fh.LikeOrDislike = mov.LikeOrDislike == "Favourite" ? 1 : (mov.LikeOrDislike == "Hated" ? 0 : -1);
            fh.Movie_Name = mov.Movie_Name;

            return fh;
        }

        #endregion

        #region PUT functions

        /// <summary>
        /// Adds a movie to database
        /// </summary>
        /// <param name="movie">movie that should be added</param>
        /// <param name="UserID">Current user ID</param>
        public void PutMovie(Movie movie, int UserID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();

            MainMovieList m = new MainMovieList();
            Favourite_Hated fh = new Favourite_Hated();

            m = ConvertMovieToMainMovieList(movie, UserID);
            fh = ConvertMovieToFavourite_Hated(movie, UserID);
            db.MainMovieList.Add(m);
            db.Favourite_Hated.Add(fh);

            db.SaveChanges();
        }

        /// <summary>
        /// Adds Movie to playlist
        /// </summary>
        /// <param name="movID">ID of movie that will be added</param>
        /// <param name="UserID">User that adds movie</param>
        /// <param name="plID">ID of playlist to which movie will be added</param>
        public void PutMovieToPlaylist(int movID, int UserID, int plID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            Playlist MyPlaylist = new Playlist();
            MyPlaylist.FilmID = movID;
            MyPlaylist.PlaylistID = plID;
            MyPlaylist.UserID = UserID;

            db.Playlist.Add(MyPlaylist);

            db.SaveChanges();
        }

        /// <summary>
        /// Add new playlist to List_Of_Playlists
        /// </summary>
        /// <param name="username">Name of user that adds a playlist</param>
        public void PutPlaylist(String username)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            var user = db.Users.SingleOrDefault(o => o.Username== username);
            var i = user.Number_Of_Playlists;
            user.Number_Of_Playlists++;
            List_Of_Playlists playlist = new List_Of_Playlists();

            while (true)
            {
                var pl = db.List_Of_Playlists.SingleOrDefault(o => o.ID == i + 1 && o.UserID == user.UserID);
                if (pl != null)
                {
                    i++;
                }
                else
                {
                    break;
                }
            }

            playlist.ID = i + 1;
            playlist.UserID = user.UserID;
            playlist.Playlist_Name = "Playlist" + playlist.ID;

            db.List_Of_Playlists.Add(playlist);
            db.SaveChanges();
        }

        #endregion

        #region DELETE functions

        /// <summary>
        /// Removes a movie from database
        /// </summary>
        /// <param name="id">id of removed movie</param>
        /// <returns>true if succed or false if not</returns>
        public bool DeleteMovie(int id)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            var deletedMML = db.MainMovieList.FirstOrDefault(p => p.ID == id);
            if (deletedMML == null)
                return false;
            else
            {
                DeleteMovieFromAllFavourite_Hated(id);
                DeleteMovieFromAllPlaylists(id);
                db.MainMovieList.Remove(deletedMML);

                db.SaveChanges();
            }
            return true;
        }

        /// <summary>
        /// Remove playlist for user
        /// </summary>
        /// <param name="plID">ID of playlist that will be removed</param>
        /// <param name="usrID">ID of user that have this playlist</param>
        public void DeletePlaylist(int plID, int usrID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            foreach (Playlist pl in db.Playlist)
            {
                if (pl.PlaylistID == plID && pl.UserID == usrID)
                    db.Playlist.Remove(pl);
            }

            foreach (List_Of_Playlists lop in db.List_Of_Playlists)
            {
                if (lop.ID == plID && lop.UserID == usrID)
                {
                    db.List_Of_Playlists.Remove(lop);
                    DecreseNumberOfPlaylistForUser(usrID);
                }
            }
            db.SaveChanges();
        }

        /// <summary>
        /// removes movie with given id from all playlists
        /// </summary>
        /// <param name="id">ID of movie that will be deleted</param>
        public void DeleteMovieFromAllPlaylists(int id)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            foreach (Playlist pl in db.Playlist)
            {
                if (pl.FilmID == id)
                {
                    db.Playlist.Remove(pl);
                }
            }
        }

        /// <summary>
        /// removes movie with given id from Favourite_Hated
        /// </summary>
        /// <param name="id">ID of movie that will be deleted</param>
        public void DeleteMovieFromAllFavourite_Hated(int id)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            foreach (Favourite_Hated fh in db.Favourite_Hated)
            {
                if (fh.FilmID == id)
                {
                    db.Favourite_Hated.Remove(fh);
                }
            }
        }

        /// <summary>
        /// Removes the movie from given playlist
        /// </summary>
        /// <param name="movID">ID of movie that will be removed from playlist</param>
        /// <param name="UserID">ID of user that removes movie from playlist</param>
        /// <param name="plID">ID of playlist from which the movie will be removed</param>
        public void DeleteMovieFromPlaylist(int movID, int UserID, int plID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            foreach (var mov in db.Playlist)
            {
                if (mov.ID == movID && mov.PlaylistID == plID && mov.UserID == UserID)
                {
                    db.Playlist.Remove(mov);

                    db.SaveChanges();
                }
            }
        }

        #endregion

        #region GET functions

        /// <summary>
        /// Gets movie with described id
        /// </summary>
        /// <param name="id">id of searched movie</param>
        /// <returns>Movie that is searched</returns>
        public Favourite_HatedObject GetMovie_FromFavouriteHated_ById_ForUser(int id, int UserID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();

            List<Favourite_HatedObject> list = new List<Favourite_HatedObject>();

            list = GetAllMovies_FromFavouriteHated_ForUser(UserID);

            foreach (Favourite_HatedObject mov in list)
            {
                if (mov.FilmID == id)
                    return mov;
            }

            return null;
        }

        /// <summary>
        /// Gets movie with MovieID = id
        /// </summary>
        /// <param name="id">id of searched movie</param>
        /// <returns>requested Movie file</returns>
        public MainMovieListObject GetMovie_FromMainMovieList_ById(int id)
        {
            List<MainMovieListObject> list = new List<MainMovieListObject>();
            list = GetAllMovies_FromMainMovieList();

            foreach (MainMovieListObject mov in list)
            {
                if (mov.ID == id)
                    return mov;
            }
            return null;
        }

        /// <summary>
        /// Gets the list of all movies from database
        /// </summary>
        /// <returns>returns list of all movies from database (MainMovieList element)</returns>
        public List<MainMovieListObject> GetAllMovies_FromMainMovieList()
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            List<MainMovieListObject> movies = new List<MainMovieListObject>();

            var movieQuery = (from mml in db.MainMovieList

                              select new MainMovieListObject
                              {
                                  ID = mml.ID,
                                  File_Name = mml.File_Name,
                                  File_Path = mml.File_Name,
                                  original_title = mml.original_title,
                                  budget = mml.budget,
                                  movie_id = mml.movie_id,
                                  imdb_id = mml.imdb_id,
                                  overview = mml.overview,
                                  popularity = mml.popularity,
                                  poster_path = mml.poster_path,
                                  release_date = mml.release_date,
                                  runtime = mml.runtime,
                                  vote_count = mml.vote_count,
                                  genre = mml.genre,

                              }).ToList();


           return movieQuery;
        }

        /// <summary>
        /// Gets all movies for given user
        /// </summary>
        /// <param name="UserID">User's ID</param>
        /// <returns>returns list of movies of given user</returns>
        public List<Favourite_HatedObject> GetAllMovies_FromFavouriteHated_ForUser(int UserID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();

            var movieQuery = (from mml in db.MainMovieList
                              join fh in db.Favourite_Hated on new { ID = mml.ID } equals new { ID = fh.FilmID } into fh_join
                              from fh in fh_join.DefaultIfEmpty()
                              where fh.UserID == UserID
                              select new Favourite_HatedObject
                              {
                                  FilmID = mml.ID,
                                  UserID = UserID,
                                  LikeOrDislike = (fh.LikeOrDislike == 1 ? "Favourite" : (fh.LikeOrDislike == 0 ? "Hated" : "")),
                                  MovieName = fh.Movie_Name
                              }).ToList();

            return movieQuery;
        }

        /// <summary>
        /// Gets list of MainMovieList elements (movies) for given user
        /// </summary>
        /// <param name="userid">ID of user whose movies we want to get</param>
        /// <returns>List of movies for user (MainMovieList element)</returns>
        public List<MainMovieListObject> GetAllMovies_FromMainMovieList_ForUser(int userid)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();

            var movieList = (from mml in db.MainMovieList
                             join fh in db.Favourite_Hated on new { ID = mml.ID } equals new { ID = fh.FilmID } into fh_join
                             from fh in fh_join.DefaultIfEmpty()
                             where fh.UserID == userid
                             select new MainMovieListObject
                             {
                                 ID = mml.ID,
                                 File_Name = mml.File_Name,
                                 File_Path = mml.File_Path,
                                 original_title = mml.original_title,
                                 budget = (int)mml.budget,
                                 movie_id = (int)mml.movie_id,
                                 imdb_id = mml.imdb_id,
                                 overview = mml.overview,
                                 popularity = (int)mml.popularity,
                                 poster_path = mml.poster_path,
                                 release_date = mml.release_date,
                                 runtime = mml.runtime,
                                 vote_count = (int)mml.vote_count,
                                 genre = mml.genre
                             }).ToList();

            return movieList;
        }

        /// <summary>
        /// Gets all playlists
        /// </summary>
        /// <returns>List of playlists</returns>
        public List<List_Of_PlaylistsObject> GetAllPlaylists()
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();

            var playlistQuery = (from lop in db.List_Of_Playlists

                              select new List_Of_PlaylistsObject
                              {
                                  ID = lop.ID,
                                  UserID = lop.UserID,
                                  PlaylistName = lop.Playlist_Name
                              }).ToList();

            return playlistQuery;

        }

        /// <summary>
        /// Gets all playlists of given user
        /// </summary>
        /// <param name="userid">ID of user whose playlists we want to get</param>
        /// <returns>List of user's playlists</returns>
        public List<List_Of_PlaylistsObject> GetAllPlaylists_ForUser(int userid)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();

            List<List_Of_PlaylistsObject> movies = new List<List_Of_PlaylistsObject>();

            var playlistQuery = (from lop in db.List_Of_Playlists
                                 where lop.UserID == userid
                                 select new List_Of_PlaylistsObject
                                 {
                                     ID = lop.ID,
                                     UserID = lop.UserID,
                                     PlaylistName = lop.Playlist_Name
                                 }).ToList();

            return playlistQuery;
        }

        //I am not sure about type of output (we don't have info about likeordislike and user)
        /// <summary>
        /// Gets movies from playlist with given id
        /// </summary>
        /// <param name="playlistid">ID of playlist from which we will get movies</param>
        /// <returns>List of movies from playlists</returns>
        public List<MainMovieListObject> GetMovies_FromPlaylist_ByPlaylistID(int playlistid, int userid)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();

            List<MainMovieListObject> movies = new List<MainMovieListObject>();

            var playlistQuery = (from pl in db.Playlist
                                 where pl.PlaylistID == playlistid & pl.UserID == userid
                                 select new PlaylistObject
                                 {
                                     ID = pl.ID,
                                     UserID = pl.UserID,
                                     FilmID = pl.FilmID,
                                     PlaylistID = pl.PlaylistID
                                 }).ToList();

            foreach(PlaylistObject pl in playlistQuery)
            {
                movies.Add(GetMovie_FromMainMovieList_ById(pl.FilmID));
            }
            return movies;
        }

        /// <summary>
        /// returns playlist with given id for given user
        /// </summary>
        /// <param name="playlistid">ID of playist that is searched</param>
        /// <param name="userid">ID of user that search his playlist</param>
        /// <returns>Playlists for given id and user</returns>
        public List_Of_PlaylistsObject GetPlaylist_ByID_ForUser(int playlistid, int userid)
        {
            List<List_Of_PlaylistsObject> list = GetAllPlaylists_ForUser(userid);
            foreach(List_Of_PlaylistsObject lop in list)
            {
                if (lop.ID == playlistid)
                    return lop;
            }
            return null;
        }

        /// <summary>
        /// Gets info about user
        /// </summary>
        /// <param name="username">Name of searched user</param>
        /// <returns>Info about user</returns>
        public UserObject GetUser_ByUserName(String username)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();

            Users user = db.Users.SingleOrDefault(usr => usr.Username == username);
            int id = user.UserID;
            String name = user.Username;
            int numberOfPlaylists = user.Number_Of_Playlists;

            UserObject UserOutput = new UserObject(id, name, numberOfPlaylists);
            //{
            //                         UserID = user.UserID,
            //                         UserName = user.Username,
            //                         Number_Of_Playlists = user.Number_Of_Playlists
            //                     };

            return UserOutput;
        }

        /// <summary>
        /// Get information to be displayed in dataGridView1
        /// </summary>
        /// <param name="username">name of currentUser</param>
        /// <returns>Return list of movies to add to dataGridView1</returns>
        public List<Movie> GetMoviesToBeDisplayedInMainGridForUser(String username)
        {
            UserObject user = GetUser_ByUserName(username);
            int UserID = user.UserID;

            MovieDatabaseEntities db = new MovieDatabaseEntities();

            var movieList = (from mml in db.MainMovieList
                             join fh in db.Favourite_Hated on new { ID = mml.ID } equals new { ID = fh.FilmID } into fh_join
                             from fh in fh_join.DefaultIfEmpty()
                             where
                               fh.UserID == UserID
                             select new Movie
                             {
                                 MovieID = mml.ID,
                                 Movie_Name = fh.Movie_Name,
                                 File_Name = mml.File_Name,
                                 LikeOrDislike = fh.LikeOrDislike == 1 ? "Favourite" : (fh.LikeOrDislike == 0 ? "Hated" : ""),
                                 Path = mml.File_Path
                             }).ToList();

            return movieList;
        }

        /// <summary>
        /// Validate if a user exists in the database and if the password is correct
        /// </summary>
        /// <param name="username">User name given in the textbox</param>
        /// <param name="password">Password of user given in the textbox</param>
        /// <returns>True if succeded, false if failed</returns>
        public bool GetLoginValidation(String username, String password)
        {
            bool validation = false;

            // Code for validation from database
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            foreach (var user in db.Users)
            {
                if (user.Username == username && user.Password == password)
                {
                    validation = true;
                }
            }
            return validation;
        }

        /// <summary>
        /// Gets movie with given file name
        /// </summary>
        /// <param name="moviename">File_Name of movie that we want to get</param>
        /// <returns></returns>
        public MainMovieListObject GetMovieByFile_Name(String moviename)
        {
            List<MainMovieListObject> list = new List<MainMovieListObject>();
            list = GetAllMovies_FromMainMovieList();

            foreach (MainMovieListObject mov in list)
            {
                if (mov.File_Name == moviename)
                    return mov;
            }
            return null;
        }

        /// <summary>
        /// Check if poster_path is not null
        /// </summary>
        /// <param name="path">path of file we want to check</param>
        /// <returns>true if movie has poster_path or false if not</returns>
        public bool GetIfPosterPathIsNotNull(String path)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
                    var result = db.MainMovieList.SingleOrDefault(o => o.File_Path == path);
                    if (result.poster_path != null)
                        return true;
                    else
                        return false;
        }

        #endregion

        #region UPDATE functions

        /// <summary>
        /// Updates Movie's name for given user
        /// </summary>
        /// <param name="movID">ID of movie that will have name changed</param>
        /// <param name="newMovieName">new name of Movie</param>
        /// <param name="UserID">ID of user that want to change name of movie</param>
        /// <returns>true if operation succeed or false if it failed</returns>
        public bool UpdateMovieName(int movID, String newMovieName, int UserID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            Favourite_Hated movie = new Favourite_Hated();

            if (movID <= 0)
            {
                Console.WriteLine("Movie's ID: ", "Movie's ID have to be greater than 0");
                return false;
            }


            movie = db.Favourite_Hated.FirstOrDefault(p => p.FilmID == movID && p.UserID == UserID);
            if (movID == 0)
            {
                Console.WriteLine("No such movie: ", "There is no movie with ID " + movID + " for user with ID " + UserID + "!");
                return false;
            }

            movie.Movie_Name = newMovieName;
            db.SaveChanges();
            return true;
        }

        /// <summary>
        /// Updates Playlist's name for given user
        /// </summary>
        /// <param name="movID">ID of playlist that will have name changed</param>
        /// <param name="newMovieName">new name of Playlist</param>
        /// <param name="UserID">ID of user that want to change name of playlist</param>
        /// <returns>true if operation succeed or false if it failed</returns>
        public bool UpdatePlaylistName(int plID, String newPlaylistName, int UserID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            List_Of_Playlists playlist = new List_Of_Playlists();

            if (plID <= 0)
            {
                Console.WriteLine("Playlist's ID: ", "Playlist's ID have to be greater than 0");
                return false;
            }


            playlist = db.List_Of_Playlists.FirstOrDefault(p => p.ID == plID && p.UserID == UserID);
            if (playlist == null)
            {
                Console.WriteLine("No such playlist: ", "There is no playlist with ID " + plID + " for user with ID " + UserID + "!");
                return false;
            }

            playlist.Playlist_Name = newPlaylistName;
            db.SaveChanges();
            return true;
        }

        /// <summary>
        /// Changes LikeOrDislike state in Favourite_Hated
        /// </summary>
        /// <param name="id">Id of movie that will have state changed</param>
        /// <param name="UserID">ID of user that will have changed stated of movie</param>
        /// <param name="state">State to which it will be changed LikeOrDislike parameter</param>
        public void UpdateToFavouriteHated(int id, int UserID, int state)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            foreach (Favourite_Hated fh in db.Favourite_Hated)
            {
                if (fh.FilmID == id && fh.UserID == UserID)
                {
                    fh.LikeOrDislike = state;
                }
                db.SaveChanges();
            }
        }

        /// <summary>
        /// Changes file_path of the movie
        /// </summary>
        /// <param name="newpath">New path that will be inserted in place of previous one</param>
        /// <param name="moviename">File_Name of movie that will have changed path</param>
        public void UpdateMoviePath(String newpath , String moviename)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();
            var result = db.MainMovieList.SingleOrDefault(o => o.File_Name == moviename);

            result.File_Path = newpath;
            db.SaveChanges();
        }

        #endregion

        #region Additional private functions

        /// <summary>
        /// decrease user's number of playlist value
        /// </summary>
        /// <param name="userID">ID of user that will have decreased number of playlists</param>
        public void DecreseNumberOfPlaylistForUser(int userID)
        {
            MovieDatabaseEntities db = new MovieDatabaseEntities();

            foreach (var usr in db.Users)
                if (usr.UserID == userID)
                    usr.Number_Of_Playlists--;
            db.SaveChanges();
        }

        #endregion
    }
}