// Core Part about Movie Recommendations

//===========================================

object CW7b {

//

//     The function should ReTurn the CSV-file appropriately broken

//     the header of the CSV-file). The result is a list of strings (lines

  val site = Source.fromURL(url, "ISO-8859-1")

  val site_string = site.mkString

  val output = (site_string.split("\n")).toList

  output.tail

  // get_csv_url("https://nms.kcl.ac.uk/christian.urban/ratings.csv")

//val ratings_url = """https://nms.kcl.ac.uk/christian.urban/ratings.csv"""

//val movies_url = """https://nms.kcl.ac.uk/christian.urban/movies.csv"""

// testcases

//-----------

//:

  // val ratings = get_csv_url(ratings_url)

// (2) Implement two functions that process the CSV-files from (1). The ratings

//     function filters out all ratings below 4 and ReTurns a list of 

//     (userID, movieID) pairs. The movies function just ReTurns a list 

//     of (movieID, title) pairs. Note the input to these functions, that is

//     the argument lines, will be the output of the function get_csv_url.

  val filter = lines.filter(_.last.asDigit >=4)

  val output = (for(i <- 0 until filter.length) yield ((filter(i).split(",").toList)(0), (filter(i).split(",").toList)(1))).toList

  output

  val output = (for(i <- 0 until lines.length) yield ((lines(i).split(",").toList)(0), (lines(i).split(",").toList)(1))).toList

  output

}

def process_ratings2(lines: List[String]) : List[(String, String)] = {

  for (cols <- lines.map(_.split(",").toList); 

       if (cols(2).toFloat >= 4)) yield (cols(0), cols(1))  

}

def process_movies2(lines: List[String]) : List[(String, String)] = {

// testcases

//-----------

// (3) Implement a grouping function that calculates a Map

//     containing the userIDs and all the corresponding recommendations 

//     (list of movieIDs). This  should be implemented in a tail

//     recursive fashion, using a Map m as accumulator. This Map m

//     is set to Map() at the beginning of the calculation.

val ratings_url = """https://nms.kcl.ac.uk/christian.urban/ratings.csv"""

val ratings = get_csv_url(ratings_url)

val good_ratings = process_ratings(ratings)

val v515 = good_ratings.filter(_._1 == "515")

val v515_2 = v515.map(_._2)

              m: Map[String, List[String]]) : Map[String, List[String]] = {

val users = (for((k,v) <- ratings) yield k).distinct

val movie_ids = (for(i <- 1 to users.length) yield

  (for ((k,v) <- ratings if(i.toString == k)) yield v).toList).toList

  val out_map = (users zip movie_ids).toMap

out_map

}

def groupById2(ratings: List[(String, String)], 

    groupById2(rest, new_ratings)

val ls0_urban = 

  List(("1", "a"), ("1", "c"), ("1", "c"))

groupById(ls0_urban, Map())

groupById2(ls0_urban, Map())

val ls00_urban = 

  List(("3", "a"), ("3", "c"), ("3", "c"))

groupById(ls00_urban, Map())

groupById2(ls00_urban, Map())

groupById(good_ratings, Map()).getOrElse("515", Nil)

groupById2(good_ratings, Map()).getOrElse("515", Nil)

val ls1_urban = 

  List(("1", "a"), ("2", "a"), 

       ("1", "c"), ("2", "a"), ("1", "c"))

groupById(ls1_urban, Map())

groupById2(ls1_urban, Map())

val ls2_urban = 

  List(("1", "a"), ("1", "b"), ("2", "x"), 

       ("3", "a"), ("2", "y"), ("3", "c"))

groupById(ls2_urban, Map())

groupById2(ls2_urban, Map())

val ls3_urban = (1 to 1000 by 10).map(_.toString).toList

val ls4_urban = ls3_urban zip ls3_urban.tail

val ls5_urban = ls4_urban ::: ls4_urban.reverse

groupById(ls5_urban, Map()) == groupById2(ls5_urban, Map())

groupById(ls5_urban, Map())

groupById2(ls5_urban, Map())

groupById(v515, Map())

groupById2(v515, Map())

groupById(v515.take(1), Map())

groupById2(v515.take(2), Map())

// testcases

//-----------

//ratings_map.get("414").get.map(movies_map.get(_)).length

//    => most prolific recommender with 1227 positive ratings

//ratings_map.get("475").get.map(movies_map.get(_)).length

//    => second-most prolific recommender with 787 positive ratings

//ratings_map.get("214").get.map(movies_map.get(_)).length 

//    => least prolific recommender with only 1 positive rating

// (4) Implement a function that takes a ratings map and a movie_name as argument.

//     The function calculates all suggestions containing

//     the movie in its recommendations. It ReTurns a list of all these

//     recommendations (each of them is a list and needs to have the movie deleted, 

//     otherwise it might happen we recommend the same movie).

def favourites(m: Map[String, List[String]], mov: String) : List[List[String]] = {

 (for((k,v) <- m if (v.contains(mov))) yield v.filter(_!=mov).toList).toList

}

def favourites2(m: Map[String, List[String]], mov: String) : List[List[String]] = 

// testcases

//-----------

//     map and a movie_name as arguments. It calculates all the recommended

//     movies sorted according to the most frequently suggested movie(s) first.

                mov_name: String) : List[String] = {

  val flat = favourites(recs, mov_name).flatten.groupMapReduce(identity)(_ => 1)(_ + _)

  val sorted = flat.toList.sortWith(_._2 > _._2).map(_._1)

  sorted

}

def mapValues[S, T, R](m: Map[S, T], f: T => R) =

  m.map { case (x, y) => (x, f(y)) }

def suggestions2(recs: Map[String, List[String]], 

  val favs_counted = mapValues(favs.groupBy(identity), (v:List[String]) => v.size).toList

// testcases

//-----------

// (6) Implement a recommendations function which generates at most

//     *two* of the most frequently suggested movies. It ReTurns the 

//     actual movie names, not the movieIDs.

                    movs: Map[String, String],

                    mov_name: String) : List[String] = {

  val sugg = suggestions(recs, mov_name)

  val movies = (for (i <- 0 until 2 if (i < sugg.length)) yield movs(sugg(i))).toList

  movies

}

//-----------

//recommendations(ratings_map, movies_map, "260")

// is the number of how many times the movie was recommended. 

  val movies = (((for((k,v) <- movs) yield recommendations(recs, movs, k)).toList).flatten).groupMapReduce(identity)(_ => 1)(_ + _)

  val sorted = movies.toList.sortWith(_._2 > _._2)

  sorted

// testcase

//

}