import os
import numpy as np

#实现一个sigmoid函数
def sigmoid(z):
        return 1./(1 + np.exp(-z))
        
# 获取movie文件内容
def get_item_info(input_file):
    """
    get item info[title, genre]
    Args(参数):
        input_file:item info file
    Return(输出):
        a dict:{key:itemid, value:[title, genre]}
    """
    if not os.path.exists(input_file):
        return {}
    item_info = {}
    linenum = 0 
    fp = open(input_file)
    for line in fp:
        if linenum == 0:
            linenum += 1
            continue
        item = line.strip().split(',')  # strip方法为移除字符串头尾的指定字符，默认为空格和换行符
        if len(item) < 3:
            continue
        elif len(item) == 3:
            itemid, title, genre = item[0], item[1], item[2]
        elif len(item) > 3:
            itemid = item[0]
            genre = item[-1]
            title = ",".join(item[1:-1])
            
        item_info.update({itemid:[title, genre]})
        
    fp.close()

    return item_info


# 下面获得评分文件
def get_ave_score(input_file):
    """
    get item ave rating score
    Args:
        input file:user rating file
    Return:
        a dict: key:itemid, value:ave_score
    """
    if not os.path.exists(input_file):
        return {}
    record_dict = {}  #用来记录读取的每个电影的评分人数与总分为之后计算平均分作准备，Key：itemid , value：[数量，评分之和]
    score_dict = {}  #之后用来返回平均评分
    linenum = 0 
    fp = open(input_file)
    for line in fp:
        if linenum == 0:
            linenum += 1
            continue
        item = line.strip().split(',')  # strip方法为移除字符串头尾的指定字符，默认为空格和换行符
        if len(item) < 4:
            continue
        userid, itemid, rating = item[0], item[1], float(item[2])
        if itemid not in record_dict:
            record_dict[itemid] = [0, 0]
        record_dict[itemid][0] += 1
        record_dict[itemid][1] += rating
        
            
    for key, value in record_dict.items():
        score_dict.update({key:round(value[1]/value[0], 3)})  # round()方法是用来保留小数的，第二个参数3表示三位小数
        
    fp.close()
    return score_dict

# 为模型提供训练样本
def get_train_data(input_file):
    """
    get train data for LFM model
    Args:
        input file : user item rating file
    Return:
        a list [(userid, itemid, label), (userid1, itemid1, label)]
    """
    if not os.path.exists(input_file):
        return []

    score_dict = get_ave_score(input_file)

    score_thr = 4.0 #正负样本的分数阈值
    linenum = 0 
    pos_dict = {} #正样本字典
    neg_dict = {} #负样本字典
    train_data = [] #输出用的列表
    fp = open(input_file)

    for line in fp:
        if linenum == 0:
            linenum += 1
            continue
        item = line.strip().split(',')
        if len(item) < 4:
            continue
        userid, itemid, rating = item[0], item[1], float(item[2])
        if userid not in pos_dict:
            pos_dict.update({userid:[]})
        if userid not in neg_dict:
            neg_dict.update({userid:[]})
        if rating >= score_thr:  #以score_thr为阈值判断样本正负
            pos_dict.get(userid).append((itemid, 1))
        else:
            score = score_dict.get(itemid, 0) #没取到就返回0
            neg_dict.get(userid).append((itemid, score))
    
    fp.close()
    for key, _ in pos_dict.items():
        datanum = min(len(pos_dict.get(key)), len(neg_dict.get(key)))
        if datanum > 0:
            train_data += [(key, value[0], value[1]) for value in pos_dict.get(key)][:datanum]  #这个datanum是为了不让正负样本数量差距过大，这样的话二者数量一样。
        else:
            continue
        #下面对该userid对应的负样本进行一个按照得分的list降序排序，reverse=True则为降序，默认为False升序
        sorted_neg_list = sorted(neg_dict.get(key), key=lambda element:element[1], reverse=True)[:datanum]  #这个datanum是为了不让正负样本数量差距过大，这样的话二者数量一样。
        train_data += [(key, value[0], 0) for value in sorted_neg_list]
    
    return train_data  #[(userid, itemid, label), (userid, itemid, label), ......]
    
# 首先是模型训练函数
def lfm_train(train_data, F, alpha, lr, epochs): 
    """
    Args:
        train_data: 训练数据， 
        F:          隐语义向量长度， 
        alpha:      正则化参数， 
        lr:         模型学习率， 
        epochs:      迭代次数
    Return :
        dict_user_vec:  {userid : np.ndarray}
        dict_item_vec:  {itemid : np.ndarray}
    """
    user_vec = {}
    item_vec = {}

    # 下面是模型参数训练过程
    for e in range(epochs):
        for data_instance in train_data:
            userid, itemid, label = data_instance
            if userid not in user_vec:
                user_vec.update({userid : init_model(F)})
            if itemid not in item_vec:
                item_vec.update({itemid : init_model(F)})
        delta = label - model_predict(user_vec.get(userid), item_vec.get(itemid)) #损失函数
        for index in range(F):  #进行参数调整
            user_vec.get(userid)[index] += lr*(delta*item_vec.get(itemid)[index]) - lr*user_vec.get(userid)[index]
            item_vec.get(itemid)[index] += lr*(delta*user_vec.get(userid)[index]) - lr*item_vec.get(itemid)[index]
        
        lr = lr * 0.9
    return user_vec, item_vec



# 然后是模型初始化函数
import numpy as np

def init_model(vector_len):
    """
    Args:
        vector_len 隐语义向量长度
    Return:
        a ndarray
    """
    return np.random.randn(vector_len)


# 模型进行打分
def model_predict(user_vec, item_vec):
    """
    Args:
        user_vec:   表示用户向量
        item_vec:   表示物品向量
    Return:
        a num 表示两个向量做出的评分，即相似度
    """

    # 结果就是求cos，两个向量内积除以两个向量模乘积
    return sigmoid(np.dot(user_vec, item_vec) / (np.linalg.norm(user_vec) * np.linalg.norm(item_vec)))



# 得到模型推荐结果
def get_recom_result(user_vec, item_vec, userid):
    """
    Args:
        user_vec:   lfm模型的输出结果
        item_vec:   lfm模型输出结果
        userid:     想得到的某个具体用户的推荐结果
    Return:
        a list :    [(itemid, score), (itemid, score), ......]
    """
    topK = 10 
    record = {}
    recom_list = []

    if userid not in user_vec:
        return []
    user_vector = user_vec.get(userid)
    for itemid, item_vector in item_vec.items():
        res = float(np.dot(user_vector, item_vector) / (np.linalg.norm(user_vector) * np.linalg.norm(item_vector)))
        #print(res)
        record.update({itemid : res})
    
    for value in sorted(record.items(), key=lambda v:v[1], reverse=True)[: topK]:
        # dict.items()相当于将字典变成了一个元组列表，比如[(key1, val1), (key2, val2)]。
        # 所以现在的value是一个元组(key, val)
        recom_list.append((value[0], round(value[1], 3)))
    
    return recom_list



# 对推荐结果进行评估
def ana_recom_result(train_data, userid, recom_list):
    """
    Args:
        train_data: 训练数据
        userid:     用户id
        recom_list: lfm推荐列表
    """
    # 将推荐得到的结果映射到具体的电影名。并与该用户本身postive的电影进行对比看看效果
    item_info = get_item_info("./data/movies.txt") 
    
    print("用户正样本：")
    for data_instance in train_data:
        temp_userid, itemid, label = data_instance
        if temp_userid == userid and label == 1:
            print(item_info.get(itemid))
    
    print("推荐结果：")
    for val in recom_list:
        print(item_info.get(val[0]))



# 最后假设对24号用户进行电影推荐
pred_userid = "24"
train_data = get_train_data("./data/ratings.txt")
user_vec, item_vec =lfm_train(train_data, 50, 0.01, 0.1, 50)
recom_list = get_recom_result(user_vec, item_vec, pred_userid)
ana_recom_result(train_data, pred_userid, recom_list)