import numpy as np
import pandas as pd
from scipy import spatial

# ratings_small 데이터 로드
rating_df = pd.read_csv("ratings_small.csv")
rating_df.tail()

## 타임스템프 컬럼은 불필요하므로 제거
rating_df.drop('timestamp', axis=1, inplace = True)

rating_df.tail()

links_df = pd.read_csv("links_small.csv")
links_df.tail()

# 결측값 제거
links_df = links_df.dropna()
pd.options.display.float_format = '{:.0f}'.format
## 판다스의 디스플레이 옵션을 설정하는데 float format을 소수점 제거를 해준다.

links_df['tmdbId'] = links_df['tmdbId'].astype('int64')
links_df.tail()

metadata_df = pd.read_csv("movies_metadata.csv", low_memory = False)
## low_memory = False -> 메모리를 많이 사용해서 데이터를 크게 가져오겠다.
metadata_df.tail()

# 필요한 컬럼들의 데이터만 추출
metadata_df = metadata_df[['id','original_title','title','runtime']]
metadata_df.tail()

# links_small를 이용하면 rating_df과 metadata를 검색할 수 있다.

def id_to_movie(id_num):
    pd.options.display.float_format = '{:.0f}'.format
    ## 판다스의 디스플레이 옵션을 설정하는데 float format을 소수점 제거를 해준다.
    
    tmdbId = links_df.loc[links_df["movieId"]==id_num]['tmdbId'].values[0]
    movie_info = metadata_df.loc[metadata_df['id'] == str(tmdbId)]
    
    pd.reset_option('display')
    ## 위에 설정한 옵션해제
    
    return movie_info

id_to_movie(6365)

u_user = rating_df['userId'].unique()
len(u_user)

## 671명의 유저가 약 10만건의 rating을 매긴것으로 확인됨

u_movie = rating_df['movieId'].unique()
len(u_movie)
## 약 9000개의 영화

u_rating = rating_df['rating'].unique()
len(u_rating)
## 10가지 카테고리의 평점

rating_df.groupby('rating').size().reset_index(name='rating_count')
## 이 테이블을 보고 추천시스템 개발에 대한 기준을 잡을 수 있다.

user_counts_df = rating_df.groupby("userId").size().reset_index(name = 'user_rating_count')
user_counts_df = user_counts_df.sort_values(by=["user_rating_count"], ascending=False)
user_counts_df.tail()

user_counts_df.head()

movie_counts_df = rating_df.groupby("movieId").size().reset_index(name = 'movie_rating_count')
movie_counts_df = movie_counts_df.sort_values(by=["movie_rating_count"], ascending=False)
movie_counts_df.tail()

movie_counts_df.head()

user_limit, movie_limit = 100, 100
## 100개 이상 평가한 유저만 걸러냄
## 100번 이상 평가받은 영화면 걸러냄

filtered_userId = user_counts_df[user_counts_df['user_rating_count'] > user_limit]['userId']
filtered_userId = list(filtered_userId)
len(filtered_userId)

filtered_movieId = movie_counts_df[movie_counts_df['movie_rating_count'] > user_limit]['movieId']
filtered_movieId = list(filtered_movieId)
len(filtered_movieId)

filtered_df = rating_df[rating_df['userId'].isin(filtered_userId)]
len(filtered_df)

filtered_df = filtered_df[filtered_df['movieId'].isin(filtered_movieId)]
len(filtered_df)

filtered_df.tail()

user_df = filtered_df.pivot_table(values='rating', index = 'userId',\
                                  columns = 'movieId', fill_value=0,\
                                  aggfunc = np.average, dropna=False)
## aggfunc = np.average 중복값은 평균값으로 처리
## 데이터가 없는 경우에 0으로 채워짐

user_df.tail()

def Euclidean_Distance_Similarity(vector_1, vector_2):
    
    ## 0으로 비어있는 데이터 제거
    idx = vector_1.nonzero()[0]
    
    ## 모든데이터가 0인 경우 0을 리턴
    if len(idx) == 0:
        return 0
    
    vector_1, vector_2 = np.array(vector_1)[idx], np.array(vector_2)[idx]
    

    ## 0으로 비어있는 데이터 제거
    idx = vector_2.nonzero()[0]
    
    ## 모든데이터가 0인 경우 0을 리턴
    if len(idx) == 0:
        return 0
    
    vector_1, vector_2 = np.array(vector_1)[idx], np.array(vector_2)[idx]
    
    return np.linalg.norm(vector_1 - vector_2)

## 임시테스트
Euclidean_Distance_Similarity(user_df.loc[4], user_df.loc[8])

def Cosine_Similarity(vector_1, vector_2):
    
    ## 0으로 비어있는 데이터 제거
    idx = vector_1.nonzero()[0]
    
    ## 모든데이터가 0인 경우 0을 리턴
    if len(idx) == 0:
        return 0
    
    vector_1, vector_2 = np.array(vector_1)[idx], np.array(vector_2)[idx]
    

    ## 0으로 비어있는 데이터 제거
    idx = vector_2.nonzero()[0]
    
    ## 모든데이터가 0인 경우 0을 리턴
    if len(idx) == 0:
        return 0
    
    vector_1, vector_2 = np.array(vector_1)[idx], np.array(vector_2)[idx]
    
    return 1 - spatial.distance.cosine(vector_1, vector_2)

## 임시테스트
Cosine_Similarity(user_df.loc[4], user_df.loc[8])

def similarity_matrix(user_df, similarity_func):
    
    index = user_df.index
    
    matrix = []
    # sample_df의 로우를 하나씩 돌면서 데이터를 가져옴
    for idx_1, value_1 in user_df.iterrows():
        row = []
        for idx_2, value_2 in user_df.iterrows():
            row.append(similarity_func(value_1, value_2))
        matrix.append(row)
        
    return pd.DataFrame(matrix, columns = index, index=index)

%%time
sm_df = similarity_matrix(user_df, Cosine_Similarity)

sm_df.head(5)

def mean_score(df, sm_df, target, closer_count):
    ms_df = sm_df.drop(target)
    ms_df = ms_df.sort_values(target, ascending = False)
    ms_df = ms_df[:closer_count]
    ms_df = df.loc[ms_df.index]
    
    # 결과데이터 생성
    pred_df = pd.DataFrame(columns = df.columns)
    pred_df.loc['User'] = df.loc[target]
    pred_df.loc['Mean'] = ms_df.mean()
   
    return pred_df

## 작동테스트
pred_df = mean_score(user_df, sm_df, 4, 5)
pred_df

def recommand(pred_df, r_count=10):
    recommand_df = pred_df.T
    recommand_df = recommand_df[recommand_df["User"]==0]
    recommand_df = recommand_df.sort_values("Mean",ascending=False)
    return list(recommand_df[:r_count].index)

## 작동테스트
movie_ids = recommand(pred_df)
movie_ids

def movie_info(movie_ids):
    datas = []
    
    for movie_id in movie_ids:
        data = id_to_movie(movie_id).to_dict('records')[0]
        datas.append(data)
        
    return pd.DataFrame(datas)

df = movie_info(movie_ids)
df

def run(df, similarity_func, target, closer_count, r_count):
    
    # 유사도 행렬 데이터 만들기
    sm_df = similarity_matrix(df, similarity_func)
    
    # 예측 행렬 데이터 만들기
    pred_df = mean_score(df, sm_df, target, closer_count)
    
    # 추천 영화 movie_ids 출력
    movie_ids = recommand(pred_df, r_count)
    
    # movie_ids로 영화 정보 데이터 프레임 만들기
    result = movie_info(movie_ids)
    
    return result

# 작동테스트
result_df = run(user_df, Cosine_Similarity, 8, 5, 10)
result_df

def mae(value, pred):
    idx = value.nonzero()[0]
    value, pred = np.array(value)[idx], np.array(pred)[idx]
    
    idx = pred.nonzero()[0]
    value, pred = np.array(value)[idx], np.array(pred)[idx]
    
    return np.absolute(sum(value - pred)) / len(idx)

def evaluate(df, sm_df, closer_count):
    
    users = df.index
    evaluate_list = []
    
    for target in users:
        pred_df = mean_score(df, sm_df, target, closer_count)
        evaluate_list.append(mae(pred_df.loc["User"], pred_df.loc["Mean"]))
    
    return np.average(evaluate_list)

## 작동테스트
evaluate(user_df, sm_df, 5)