# 패키지 불러오기

import pickle # 리스트 안의 데이터프레임 형태 저장
import requests # api 요청
import json
import pandas as pd
import numpy as np
import matplotlib as mlp
import matplotlib.pyplot as plt
import seaborn as sns
import time

from skimage import io # 미니맵 처리
from sklearn.preprocessing import MinMaxScaler

%matplotlib inline
sns.set()

# 버전 확인 및 API Key 갱신
# 사용한 데이터는 9.3.261버전 데이터

api_key = 'Key' # Key를 갱신하여야 한다
r = requests.get('https://ddragon.leagueoflegends.com/api/versions.json') # version data 확인
current_version = r.json()[0] # 가장 최신 버전 확인
current_version

# Champs 데이터 받아오기

# requests 함수로 chapms 데이터 받아오기 (가장 최신 버전)
r = requests.get('http://ddragon.leagueoflegends.com/cdn/{}/data/ko_KR/champion.json'.format(current_version))
parsed_data = r.json() # 파싱
info_df = pd.DataFrame(parsed_data)
info_df.head()

# champ_info_df의 data 값들을 데이터프레임으로 변환

# 데이터의 각 행을 시리즈 형태로 변환하여 딕셔너리에 추가
champ_dic = {}
for i, champ in enumerate(info_df.data):
    champ_dic[i] = pd.Series(champ)

# 데이터 프레임 변환 후 Transpose
champ_df = pd.DataFrame(champ_dic).T

# output : 챔피언 데이터 안에도 info와 stats가 딕셔너리 형태임
# 이 데이터들을 데이터프레임으로 변환하여 각 챔피언에 대한 변수로 추가해야 한다.

# champ_df의 info, stats의 데이터를 변수로 추가
champ_info_df = pd.DataFrame(dict(champ_df['info'])).T
champ_stats_df = pd.DataFrame(dict(champ_df['stats'])).T

# 데이터 합치기
champ_df = pd.concat([champ_df, champ_info_df], axis=1)
champ_df = pd.concat([champ_df, champ_stats_df], axis=1)
# 이번 분석에서 필요없는 데이터 제거
champ_df = champ_df.drop(['version', 'image', 'info', 'stats'], axis=1)
champ_df.info()

# API에 Key를 매일 갱신하여 받아와야한다.
# API의 요청 제한은 2분에 100개인 듯하다. 언제 다 받아서 분석하지...

# api 요청

api_url_grandmaster = 'https://kr.api.riotgames.com/lol/league/v4/grandmasterleagues/by-queue/RANKED_SOLO_5x5?api_key=' + api_key
api_url_master = 'https://kr.api.riotgames.com/lol/league/v4/masterleagues/by-queue/RANKED_SOLO_5x5?api_key=' + api_key
# 그랜드마스터, 마스터 데이터 가져와서 데이터프레임으로 변환
r = requests.get(api_url_grandmaster)
league_df = pd.DataFrame(r.json())
r = requests.get(api_url_master)
league_df = pd.concat([league_df, pd.DataFrame(r.json())], axis=0)

# entries 데이터프레임으로 변환하여 추가
league_df.reset_index(inplace=True)
league_entries_df = pd.DataFrame(dict(league_df['entries'])).T
league_df = pd.concat([league_df, league_entries_df], axis=1)

league_df = league_df.drop(['index', 'queue', 'name', 'leagueId', 'entries', 'rank'], axis=1)
league_df.info()

# summonerId를 이용하여 accountId를 모두 받아와야 한다. 요청 제한으로 인해 오래 걸리므로 파일로 저장하여 관리
# API 요청 제한 : 1초에 20, 2분에 100

# league_df['account_id'] = np.nan # account_id 초기화
# for i, summoner_id in enumerate(league_df['summonerId']):
#     # 각 소환사의 SummonerId와 API Key를 포함한 url을 만들고, Summoner API에서 AccountId를 가져와 채워넣는다.
#     api_url = 'https://kr.api.riotgames.com/lol/summoner/v4/summoners/' + summoner_id + '?api_key=' + api_key
#     r = requests.get(api_url)
#     while r.status_code!=200: # 요청 제한 또는 오류로 인해 정상적으로 받아오지 않는 상태라면, 5초 간 시간을 지연
#         time.sleep(5)
#         r = requests.get(api_url)
#     account_id = r.json()['accountId']
#     league_df.iloc[i, -1] = account_id

# league_df.to_csv('LeagueData.csv')

league_df = pd.read_csv('LeagueData.csv',index_col=0)
league_df.head()

# Match info 데이터 받기 (gameId를 얻기 위해서)

# season = str(13)

# match_info_df = pd.DataFrame()
# for account_id in league_df['account_id']:
#     api_url = 'https://kr.api.riotgames.com/lol/match/v4/matchlists/by-account/' + account_id + \
#                   '?season=' + season + '&api_key=' + api_key
#     r = requests.get(api_url)
#     while r.status_code!=200: # 요청 제한 또는 오류로 인해 정상적으로 받아오지 않는 상태라면, 5초 간 시간을 지연
#         time.sleep(5)
#         r = requests.get(api_url)
#     match_info_df = pd.concat([match_info_df, pd.DataFrame(r.json()['matches'])])
# match_info_df.to_csv('MatchInfoData.csv')

# 저장된 데이터 받아오기
match_info_df = pd.read_csv('MatchInfoData.csv', index_col=0)
match_info_df.reset_index(inplace=True)

# Match 데이터 받기 (gameId를 통해 경기의 승패, 팀원과 같은 정보가 담겨있다.)

# match_info_df = match_info_df.drop_duplicates('gameId')

# match_df = pd.DataFrame()
# for game_id in match_info_df['gameId']: # 이전의 매치에 대한 정보 데이터에서 게임 아이디를 가져온다
#     api_url = 'https://kr.api.riotgames.com/lol/match/v4/matches/' + str(game_id) + '?api_key=' + api_key
#     r = requests.get(api_url)
#     while r.status_code!=200: # 요청 제한 또는 오류로 인해 정상적으로 받아오지 않는 상태라면, 5초 간 시간을 지연
#         time.sleep(5)
#         r = requests.get(api_url)
#     r_json = r.json()
#     temp_df = pd.DataFrame(list(r_json.values()), index=list(r_json.keys())).T # 게임 아이디에 대한 매치 데이터를 받아서 추가
#     match_df = pd.concat([match_df, temp_df])

# match_df.to_csv('MatchData.csv') # 파일로 저장

match_df = pd.read_csv('MatchData.csv', index_col=0)

# 정확한 통계를 위해 가장 최신의 버전과 클래식 게임에 대한 데이터만 가져오자
match_df = match_df.loc[(match_df['gameVersion']=='9.3.261.9578') &
             (match_df['gameMode']=='CLASSIC'), :]

# 그 중에서도 이번 분석에서는 소환사의 협곡 솔로 랭크와 팀 랭크 게임만 사용한다.
select_indices = (match_df['queueId']==420) | (match_df['queueId']==440)
match_df = match_df.loc[select_indices, :].reset_index(drop=True)

# DataFrame 내의 리스트들이 파일로 저장되었다가 불러지는 과정에서 문자로 인식됨
for column in ['teams', 'participants', 'participantIdentities']:
    match_df[column] = match_df[column].map(lambda v: eval(v)) # 각 값에 대해 eval 함수를 적용

match_df.head()

## 매치 데이터에서 teams, participants, participantIdentities가 최종적으로 원하는 데이터이다.

# match_teams_df = pd.DataFrame()
# for i in range(len(match_df)):
#     temp_df = pd.DataFrame(match_df['teams'].iloc[i]) # teams 데이터를 2행 짜리 데이터프레임으로 변환
#     temp_df['gameId'] = match_df['gameId'].iloc[i] # teams 데이터에 각 게임의 gameId 추가 (2행 마다 같은 값)
#     # teams 데이터에 있는 bans 데이터를 5개의 변수로 추가한다
#     ban_dict = {i: pd.DataFrame(temp_df['bans'][i]).iloc[:, 0] for i in range(2)} # 각 팀의 밴픽을 저장
#     temp_ban = pd.DataFrame(ban_dict).T
#     temp_ban.columns = [f'ban{i}' for i in range(1, 6)] # 열 이름 변경
#     temp_df = pd.concat([temp_df, temp_ban], axis=1)

#     match_teams_df = pd.concat([match_teams_df, temp_df])

# match_teams_df.to_csv('MatchTeamsData.csv')

match_teams_df = pd.read_csv('MatchTeamsData.csv', index_col=0).reset_index()
match_teams_df.drop('bans', axis=1, inplace=True)

# 각 타임라인에 찍힌 위치 정보가 필요한데, match-timelines 데이터에 모여있다.
# 그래서 이 데이터를 가져와야한다.

# match_timeline_list = []
# for game_id in tqdm(match_df['gameId']): # 각 게임 아이디마다 요청
#     api_url = f'https://kr.api.riotgames.com/lol/match/v4/timelines/by-match/{game_id}?api_key={api_key}'
#     r = requests.get(api_url)
#     while r.status_code!=200: # 요청 제한 또는 오류로 인해 정상적으로 받아오지 않는 상태라면, 3초 간 시간을 지연
#         time.sleep(3)
#         r = requests.get(api_url)
#     temp_match = pd.DataFrame(list(r.json().values())[0]) # 전체 데이터 저장 (데이터 값에 딕셔너리 형태로 필요한 정보가 저장)
#     temp_timeline = pd.DataFrame()
#     len_timeline = temp_match.shape[0]
#     for i in range(len_timeline): # 각 게임의 타임라인이 모두 다르기 때문 (1분 가량마다 타임라인이 찍힌다)
#         temp_current_timeline = pd.DataFrame(temp_match['participantFrames'].iloc[i]).T
#         if i != (len_timeline-1):
#             temp_position = pd.DataFrame(list(temp_current_timeline['position'].values), index=temp_current_timeline.index)
#             temp_current_timeline = pd.concat([temp_current_timeline, temp_position], axis=1)
#             temp_current_timeline.drop('position', axis=1, inplace=True)
#         temp_current_timeline['timestamp'] = temp_match['timestamp'][i]
#         temp_timeline = pd.concat([temp_timeline, temp_current_timeline], axis=0, sort=False)
#     match_timeline_list.append(temp_timeline)

# f = open('MatchTimelineData.pickle', 'wb') # 리스트 안의 데이터프레임 형태이므로 바이너리 코드로 저장하기 위함임
# pickle.dump(match_timeline_list, f)
# f.close()

# 블랙리스트 되서 또 11788개의 데이터만 받아왔음
match_df = match_df.iloc[:11788, :].copy()
f = open('MatchTimelineData.pickle', 'rb')
match_timeline_list = pickle.load(f)

# 강타 유무를 판단하기 위해 spell api의 정보를 받아와서 소환사의 협곡 맵에서 사용하는 스펠만 가져온다.

spell_api = 'http://ddragon.leagueoflegends.com/cdn/9.3.1/data/ko_KR/summoner.json'
r = requests.get(spell_api)
spell_info_df = pd.DataFrame(r.json())
spell = {}
for i in range(len(spell_info_df)):
    cur_spell = spell_info_df['data'].iloc[i]
    if 'CLASSIC' in cur_spell['modes']:
        spell[int(cur_spell['key'])] = cur_spell['name']
spell = sorted(spell.items(), key=lambda t : t[0])

def MapScaler(data, x_range=(-120, 14870), y_range=(-120, 14980)): # x, y의 범위
    x = data['x'].astype('float64').values.reshape(-1, 1)
    y = data['y'].astype('float64').values.reshape(-1, 1)
    x_range = np.array(x_range).astype('float64').reshape(-1, 1)
    y_range = np.array(y_range).astype('float64').reshape(-1, 1)
    scaler = MinMaxScaler(feature_range=(0, 512)) # 0~512로 변환
    scaler.fit(x_range)
    x = scaler.transform(x)
    scaler.fit(y_range)
    y = scaler.transform(y)
    return x, 512 - y

# 이미지는 왼쪽 위가 0인데, 지도는 왼쪽 아래가 0이다.
# 그래서 좌표만 뒤집어서 출력을 시키고 싶었는데, 찾기 힘들어서 임의로 y값을 뒤집었다.

cur_player = cur_timeline.loc['10'].copy()
x = cur_player['x']
y = cur_player['y']
max_lane, lane = LanePredict(cur_player, support_index==str(j), jungle_index)

maplink = 'https://s3-us-west-1.amazonaws.com/riot-developer-portal/docs/map11.png'
image = io.imread(maplink)
fig, ax = plt.subplots(1, 1, figsize=(12, 12))
ax.scatter(x, y, c='black', s=50)
ax.axis('off')
ax.imshow(image)
plt.show()

x1 = np.random.uniform(20, 60, 1000)
y1 = np.random.uniform(30, 220, 1000)

x2 = np.random.uniform(20, 150, 1500)
y2 = np.random.uniform(20, 160, 1500)

x3 = np.random.uniform(30, 200, 1000)
y3 = np.random.uniform(20, 60, 1000)
maplink = 'https://s3-us-west-1.amazonaws.com/riot-developer-portal/docs/map11.png'
image = io.imread(maplink)
fig, ax = plt.subplots(1, 1, figsize=(12, 12))
ax.scatter(x1, y1, c='black', s=50)
ax.scatter(x2, y2, c='black', s=50)
ax.scatter(x3, y3, c='black', s=50)
ax.axis('off')
ax.imshow(image)
plt.show()

def SupJugPredict(data, player_spells, i): # 서폿과 정글을 판단하기 위한 함수
    if i==1: # 블루팀
        final_timeline = data.iloc[-10:-5].copy()
        spells = player_spells[:5]
    if i==6: # 레드팀
        final_timeline = data.iloc[-5:].copy()
        spells = player_spells[5:10]
    smite_count = (spells == 11).sum()
    # 각 팀의 스마이트 개수 (스마이트가 2명 이상이 보유하면, 라인의 위치로 판단하기 위함)
    if smite_count == 0: jungle_index = final_timeline['jungleMinionsKilled'].idxmax()
    elif  smite_count > 1: jungle_index = False
    else: jungle_index = np.where(spells == 11)[0][0] + i # 강타를 들고있는 플레이어 번호

    final_timeline = final_timeline.drop(index=final_timeline['jungleMinionsKilled'].idxmax()) # 정글 제외
    return final_timeline['minionsKilled'].idxmin(), str(jungle_index) # 정글을 제외하고 cs가 가장 적은 사람이 서포터

def LanePredict(data, support_bool=False, jungle_bool=True):
    lane = {'TOP': 0, 'MID': 0, 'BOT_CARRY': 0, 'JUNGLE': 0}
    etc = 0
    for xi, yi in zip(data['x'], data['y']):
        if (xi > 20) & (xi < 60) & (yi > 30) & (yi < 220): lane['TOP'] += 1
        elif (xi > 20) & (xi < 150) & (yi > 20) & (yi < 160): lane['TOP'] += 1
        elif (xi > 30) & (xi < 200) & (yi > 20) & (yi < 60): lane['TOP'] += 1
        elif (xi > 195) & (xi < 265) & (yi > 250) & (yi < 310): lane['MID'] += 1
        elif (xi > 220) & (xi < 295) & (yi > 220) & (yi < 290): lane['MID'] += 1
        elif (xi > 250) & (xi < 320) & (yi > 200) & (yi < 260): lane['MID'] += 1
        elif (xi > 290) & (xi < 350) & (yi > 160) & (yi < 215): lane['MID'] += 1
        elif (xi > 160) & (xi < 220) & (yi > 290) & (yi < 340): lane['MID'] += 1
        elif (xi > 310) & (xi < 460) & (yi > 435) & (yi < 485): lane['BOT_CARRY'] += 1
        elif (xi > 400) & (xi < 490) & (yi > 385) & (yi < 480): lane['BOT_CARRY'] += 1
        elif (xi > 440) & (xi < 490) & (yi > 310) & (yi < 455): lane['BOT_CARRY'] += 1
        elif (xi > 0) & (xi < 170) & (yi > 340) & (yi < 512): etc += 1
        elif (xi > 340) & (xi < 512) & (yi > 0) & (yi < 170): etc += 1
        else: lane['JUNGLE'] += 1
    if jungle_bool:
        del lane['JUNGLE']
    # 예측된 서포터 번호가 봇에 가장 오래 있었으면 서포터로 확정, 아니면 라인으로 판단
    if support_bool & (max(lane, key=lane.get) == 'BOT_CARRY'): return 'BOT_SUPPORT', lane
    return max(lane, key=lane.get), lane

# 라인 계산

# lane_calculated = pd.DataFrame()
# for k in range(len(match_timeline_list)):
#     if match_df['gameDuration'][k] < 600: continue

#     cur_timeline = match_timeline_list[k].copy()
#     cur_timeline['jungleMinionsKilled'] = cur_timeline['jungleMinionsKilled'].astype('float64')
#     cur_timeline['minionsKilled'] = cur_timeline['minionsKilled'].astype('float64')
#     # 타임스탬프는 op.gg가 나타내는 아이템 타임스탬프와 비교 결과, 타임스탬프 값의 1000 단위가 1초인 것을 파악함
#     cur_timeline['timestamp'] = cur_timeline['timestamp'] / (1000*60)  # 타임스탬프 값을 분 단위로 변환
#     condition = (cur_timeline['timestamp'] > 2) & \  # 2분 이하 : 미니언이 라인 도착 전, 시야 확보와 정글 리쉬
#                 (cur_timeline['timestamp'] < 15)     # 15분 이상 : 라인전을 끝내고 다른 라인으로 이동할 수 있음
#     cur_timeline = cur_timeline.loc[condition].copy()
#     cur_timeline['x'], cur_timeline['y'] = MapScaler(cur_timeline)
#     player_spells = [(data['spell1Id'], data['spell2Id'])for data in match_df['participants'][k]] # 스펠 확인
#     player_spells = np.array(player_spells)

#     lane = {}
#     for i in range(1, 11, 5):  # 라인 계산
#         support_index, jungle_index = SupJugPredict(cur_timeline, player_spells, i)
#         for j in range(i, i+5):
#             if str(j) == jungle_index:
#                 lane[f'lane{j}'] = 'JUNGLE'
#                 continue
#             cur_player = cur_timeline.loc[str(j)].copy()
#             lane[f'lane{j}'], _ = LanePredict(cur_player, support_index==str(j), jungle_index)
#     lane['gameId'] = match_df['gameId'][k]
#     lane = pd.Series(lane)
#     if lane.value_counts().max() > 2: # 각 게임에 한 라인이 2명 이상이면 계산 착오로 판단하여 데이터 삭제
#         print(f"{k}번째 계산이 잘못되었습니다.")
#         continue
#     lane_calculated = pd.concat([lane_calculated, pd.Series(lane)], axis=1, sort=False)

# match_df = pd.concat([match_df, lane_calculated.T.reset_index(drop=True).drop('k', axis=1)], join='inner', axis=1)

# lane_calculated = lane_calculated.T.reset_index(drop=True).drop('k', axis=1)
# lane_calculated.to_csv('LaneCalculated.csv')

lane_calculated = pd.read_csv('LaneCalculated.csv', index_col=0)
match_df = pd.merge(match_df, lane_calculated, on='gameId')

player_champs = [] # 각 플레이어의 챔피언 정보를 가져온다.
for i in range(len(match_df)): # 10명의 챔피언을 딕셔너리 형태로 변환하여 저장
    cur_champs = {f'champ{j+1}': match_df['participants'][i][j]['championId'] for j in range(10)}
    cur_champs['gameId'] = match_df['gameId'][i]
    player_champs.append(cur_champs)

player_champs = pd.DataFrame(player_champs, columns=cur_champs.keys())

# use_cols = ['kills', 'deaths', 'assists', 'largestKillingSpree', 'largestMultiKill',
#             'longestTimeSpentLiving', 'totalDamageDealtToChampions', 'totalHeal', 'totalDamageTaken',
#             'goldEarned', 'turretKills', 'totalMinionsKilled', 'visionScore',
#             'firstBloodKill', 'firstBloodAssist', 'timeCCingOthers']
# # 일단 stats 정보에서 남길 데이터들을 선정하여 가져온다.

# stats_df = pd.DataFrame()
# for i in range(len(match_df)):
#     temp = pd.DataFrame()
#     for col in use_cols:
#         cur_values = {f'{col}{j+1}': match_df['participants'][i][j]['stats'][col] for j in range(10)}
#         temp = pd.concat([temp, pd.Series(cur_values)], axis=0, sort=False)
#     stats_df = pd.concat([stats_df, temp], axis=1, sort=False)
# stats_df = stats_df.T.reset_index(drop=True)
# stats_df['gameId'] = match_df['gameId']
# stats_df.to_csv('statsData.csv')

stats_df = pd.read_csv('statsData.csv', index_col=0)
stats_df = pd.merge(stats_df, player_champs)

# 원하는 것은 원딜과 서포터의 조합일 때의 데이터이므로 팀 정보는 의미없다.
# 그러므로 블루팀과 레드팀으로 나눠서 정보를 가공한 후, 합친다.

def DropColumns(data, col, i): # 각 팀에 맞게 상대팀의 필요없는 데이터는 삭제하기 위함
    for k in range(1, 6):
        data[i].drop(f'{col}{i*5+k}', axis=1, inplace=True)
        if i==0: data[i].rename(columns={f'{col}{5+k}':f'{col}{k}'}, inplace=True)
    return

use_cols = ['lane', 'champ', 'kills', 'deaths', 'assists', 'largestKillingSpree', 'largestMultiKill',
            'longestTimeSpentLiving', 'totalDamageDealtToChampions', 'totalHeal', 'totalDamageTaken',
            'goldEarned', 'turretKills', 'totalMinionsKilled', 'visionScore',
            'firstBloodKill', 'firstBloodAssist', 'timeCCingOthers']

# 팀 나누기
blue_teams_df = pd.merge(match_teams_df[match_teams_df['teamId'] == 100], lane_calculated, on='gameId')
blue_teams_df = pd.merge(blue_teams_df, stats_df, on='gameId')
red_teams_df = pd.merge(match_teams_df[match_teams_df['teamId'] == 200], lane_calculated, on='gameId')
red_teams_df = pd.merge(red_teams_df, stats_df, on='gameId')

teams = [red_teams_df, blue_teams_df] # 팀을 리스트로 만들어 포인터를 이용하여 데이터를 변환한다.
for i in range(2):
    for col in use_cols:
        DropColumns(teams, col, i)

teams_df = pd.concat([blue_teams_df, red_teams_df]).reset_index(drop=True)
teans_df.drop('index', axis=1)

# 가지고 있는 전체 플레이어에 대한 데이터를 원딜과 서포터에 대한 데이터로 변환한다.

# def ChampTrans(x):  # 챔피언 key를 이름으로 변환하는 함수
#     if x!=-1: return champ_df.loc[champ_df['key'] == str(x), 'name'].values[0]
#     return

# for i in range(1, 6):
#     teams_df[f'ban{i}'] = teams_df[f'ban{i}'].map(lambda x: ChampTrans(x)) # map 함수로 챔피언 모두 변환
#     teams_df[f'champ{i}'] = teams_df[f'champ{i}'].map(lambda x: ChampTrans(x))
#     for col in use_cols:
#         if i == 1:
#             teams_df[f'CARRY_{col}'] = np.nan
#             teams_df[f'SUPPORT_{col}'] = np.nan
#         temp_index = np.where(teams_df[f'lane{i}'] == 'BOT_CARRY')
#         teams_df[f'CARRY_{col}'].iloc[temp_index] = teams_df[f'{col}{i}'].iloc[temp_index]
#         temp_index = np.where(teams_df[f'lane{i}'] == 'BOT_SUPPORT')
#         teams_df[f'SUPPORT_{col}'].iloc[temp_index] = teams_df[f'{col}{i}'].iloc[temp_index]
# teams_df = teams_df.fillna('NONE')
# duo_df = teams_df.copy()
# duo_df.to_csv('DuoData.csv')

duo_df = pd.read_csv('DuoData.csv', index_col=0)
duo_df = duo_df.drop('index', axis=1)
duo_df['win'] = duo_df['win'].map({'Win':1, 'Fail':0}) # win을 1, fail을 0으로 변환

duo_df = pd.concat([duo_df.iloc[:, :21], duo_df.iloc[:, 111:]], axis=1, sort=False)

# 밴 확률 계산, 원딜과 서포터의 동시 밴은 너무 경우의 수가 적어서 각각의 밴률 평균으로 계산
def BanRate(row, carry, support):  
    carry_ban = 0
    support_ban = 0
    for i in range(1, 6):
        if row[f'ban{i}'] == carry: carry_ban += 1
        if row[f'ban{i}'] == support: support_ban += 1
    return (carry_ban + support_ban) / 2

def KdaCalc(row): # kda 계산 (데스가 0이면 1.2를 곱하는 방식으로 가중치 부여)
    if row['CARRY_deaths'] != 0:
        carry = (row['CARRY_kills'] + row['CARRY_assists']) / row['CARRY_deaths']
    else: carry = (row['CARRY_kills'] + row['CARRY_assists']) * 1.2
    if row['SUPPORT_deaths'] != 0:
        support = (row['SUPPORT_kills'] + row['SUPPORT_assists']) / row['SUPPORT_deaths']
    else: support = (row['SUPPORT_kills'] + row['SUPPORT_assists']) * 1.2
    return (carry+support)/2

match_count = duo_df['gameId'].count() / 2 # 한 게임당 두 행으로 구성되어 있으므로 2로 나눈다.
duo_stats = pd.DataFrame()
for carry in duo_df['CARRY_champ'].unique(): # 각 원딜과 서포터마다 계산
    for support in duo_df['SUPPORT_champ'].unique():
        condition =  (duo_df['CARRY_champ'] == carry) & \
                     (duo_df['SUPPORT_champ'] == support)
        cond_count = condition.sum()
        if cond_count < 100: continue # 바텀 듀오 데이터가 100이하면 스킵

        stat = {}
        stat['count'] = cond_count
        stat['duoChamps'] = f'{carry}&{support}'
        stat['banRate'] = duo_df.apply(lambda x: BanRate(x, carry, support), axis=1).sum() / match_count
        stat['pickRate'] = duo_df.loc[condition, 'gameId'].count() / match_count
        stat['winRate'] = duo_df.loc[condition, 'win'].sum() / cond_count
        stat['kdaMean'] = duo_df[condition].apply(KdaCalc, axis=1).mean()
        stat['largestKillingSpreeWeightMean'] = ((duo_df[condition]['CARRY_largestKillingSpree']*2 + \
                                                  duo_df[condition]['CARRY_largestKillingSpree']) / 3).mean()
        stat['largestMultiKillWeightMean'] = ((duo_df[condition]['CARRY_largestMultiKill']*2 + \
                                               duo_df[condition]['SUPPORT_largestMultiKill']) / 3).mean()
        stat['longestTimeSpentLivingMean'] = ((duo_df[condition]['CARRY_longestTimeSpentLiving'] + \
                                              duo_df[condition]['SUPPORT_longestTimeSpentLiving']) / 2).mean()
        stat['totalDamageDealtToChampionsWeightMean'] = ((duo_df[condition]['CARRY_totalDamageDealtToChampions']*2 + \
                                                          duo_df[condition]['SUPPORT_totalDamageDealtToChampions']) / 3).mean()
        stat['totalHealWeightMean'] = ((duo_df[condition]['CARRY_totalHeal'] + \
                                        duo_df[condition]['SUPPORT_totalHeal']*2) / 3).mean()
        stat['SUPPORT_totalDamageTaken'] = duo_df[condition]['SUPPORT_totalDamageTaken'].mean()
        stat['goldEarnedMean'] = ((duo_df[condition]['CARRY_goldEarned'] + \
                                  duo_df[condition]['SUPPORT_goldEarned']) / 2).mean()
        stat['turretKillsMean'] = ((duo_df[condition]['CARRY_turretKills'] + \
                                    duo_df[condition]['SUPPORT_turretKills']) / 2).mean()        
        stat['totalMinionsKilledWeightMean'] = ((duo_df[condition]['CARRY_totalMinionsKilled']*2 + \
                                                 duo_df[condition]['SUPPORT_totalMinionsKilled']) / 3).mean()
        stat['visionScoreWeightMean'] = ((duo_df[condition]['CARRY_visionScore'] + \
                                          duo_df[condition]['SUPPORT_visionScore']*2) / 3).mean()
        stat['firstBloodKillAssistMean'] = ((duo_df[condition]['CARRY_firstBloodKill'] + \
                                        duo_df[condition]['CARRY_firstBloodAssist'] + \
                                        duo_df[condition]['SUPPORT_firstBloodKill'] + \
                                        duo_df[condition]['SUPPORT_firstBloodAssist']) / 4).mean()
        stat['timeCCingOthersWeightMean'] = ((duo_df[condition]['CARRY_timeCCingOthers'] + \
                                        duo_df[condition]['SUPPORT_timeCCingOthers']*2) / 3).mean()

        duo_stats = pd.concat([duo_stats, pd.Series(stat)], axis=1, sort=False)

duo_stats = duo_stats.T.reset_index(drop=True)

duo_stats['banRate'] = duo_stats['banRate'] * 100
duo_stats['pickRate'] = duo_stats['pickRate'] * 100
duo_stats['winRate'] = duo_stats['winRate'] * 100
duo_stats['Score'] = duo_stats['winRate']*2 + duo_stats['pickRate']*2 + duo_stats['banRate']*0.1 + duo_stats['kdaMean']*1 - 40

duo_score = pd.concat([duo_stats.iloc[:, :6], duo_stats.iloc[:, -1:]], axis=1, sort=False)
duo_score = duo_score.sort_values(by='Score', ascending=False)
duo_score['Tier'] = 0
duo_score.loc[duo_score['Score'] < 65, 'Tier'] = 4
duo_score.loc[duo_score['Score'] >= 65, 'Tier'] = 3
duo_score.loc[duo_score['Score'] >= 75, 'Tier'] = 2
duo_score.loc[duo_score['Score'] >= 85, 'Tier'] = 1
duo_score

# https://www.metasrc.com 데이터 (무단 추출 죄송합니다. 문제 시, 삭제하겠습니다.)
# 데이터는 하나의 값만 제외하고 삭제하였습니다.
tier = pd.DataFrame([[48.08, 53.86, 70.17, 1.59, 0.75, 2.01]],
                     columns=['Score', 'winRate', 'roleRate', 'pickRate', 'banRate' , 'kdaRatio'])

X = tier.drop(['Score', 'roleRate'], axis=1)
y = np.array(tier['Score'])

from sklearn.linear_model import LinearRegression

linear = LinearRegression(fit_intercept=True)
linear.fit(X, y)
linear.coef_