import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import random

confirmed_df  = pd.read_csv('https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv')
deaths_df     = pd.read_csv('https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_global.csv')
recoveries_df = pd.read_csv('https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_recovered_global.csv')

latest_data = pd.read_csv('https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_daily_reports/04-16-2020.csv')

latest_data.describe()

latest_data.head()

cols = confirmed_df.keys()
cols

# Printing the dates ONLY
cols[4:]

confirmed  = confirmed_df.loc[:, cols[4]:]
deaths     = deaths_df.loc[:, cols[4]:]
recoveries = recoveries_df.loc[:, cols[4]:]

confirmed.head()

# RECALL
confirmed_df.head()

dates = confirmed.keys()
world_cases     = [confirmed[i].sum() for i in dates]
total_deaths    = [deaths[i].sum() for i in dates] 
total_recovered = [recoveries[i].sum() for i in dates] 

total_active    = (np.array(world_cases)-np.array(total_deaths)-np.array(total_recovered)).tolist()

mortality_rate  = (np.array(total_deaths)/np.array(world_cases)).tolist()
recovery_rate   = (np.array(total_recovered)/np.array(world_cases)).tolist()

import datetime

start = '1/22/2020'
start_date = datetime.datetime.strptime(start, '%m/%d/%Y')
dates_dt = [(start_date + datetime.timedelta(days=i)).strftime('%m/%d/%Y') for i in range(len(dates))]

covid_df = pd.DataFrame(
    {'Confirmed': world_cases,
     'Deaths'   : total_deaths,
     'Recovered': total_recovered,
     'Active'   : total_active
    }, index=dates_dt)
covid_df.plot(figsize=(16, 9), linewidth=4).grid(axis='y')
plt.title('Coronavirus Over Time', size=30);

covid_df.pct_change().plot(figsize=(16, 9), linewidth=4).grid(axis='y')
plt.title('Daily Change Over Time (in %)', size=30);

daily_change = covid_df.diff()
daily_change.plot.bar(figsize=(16, 9), linewidth=4, width=2).grid(axis='y')
plt.title('Daily Change Over Time', size=30)
plt.xticks(rotation=45);

daily_change.columns

daily_change.Confirmed.plot.bar(figsize=(20, 8), linewidth=4, width=0.8).grid(axis='y')
plt.title('Global Confirmed COVID-19 Cases Daily Change Over Time', size=30)
#plt.xticks(rotation=45);

daily_change.Deaths.plot.bar(figsize=(20, 8), linewidth=4, width=0.8, color='darkgoldenrod').grid(axis='y')
plt.title('Global Daily Deaths from COVID-19 Over Time', size=30);

daily_change.Recovered.plot.bar(figsize=(20, 8), linewidth=4, width=0.8, color='green').grid(axis='y')
plt.title('Global Daily Recovered Cases from COVID-19 Over Time', size=30);

daily_change.Active.plot.bar(figsize=(20, 8), linewidth=4, width=0.8, color='firebrick').grid(axis='y')
plt.title('Global Daily Change in COVID-19 Active Cases', size=30);

daily_change.Confirmed.plot.bar(figsize=(20, 8), linewidth=4, width=0.8, label='Confirmed Cases', legend=True).grid(axis='y')
daily_change.Active.plot.bar(figsize=(20, 8), linewidth=4, width=0.8, color='firebrick', label='Active', legend=True).grid(axis='y')
daily_change.Recovered.plot.bar(figsize=(20, 8), linewidth=4, width=0.8, color='green', label='Recovered', legend=True).grid(axis='y')
daily_change.Deaths.plot.bar(figsize=(20, 8), linewidth=4, width=0.8, color='darkgoldenrod', label='Deaths', legend=True).grid(axis='y')
plt.title('Global COVID-19 Daily Changes', size=30);

def get_data(country):
    cases = [confirmed_df[confirmed_df['Country/Region']==country][i].sum() for i in dates]
    daily_increase = pd.Series(cases).diff().tolist()
    deaths = [deaths_df[deaths_df['Country/Region']==country][i].sum() for i in dates]
    daily_death = pd.Series(deaths).diff().tolist()
    recoveries  = [recoveries_df[recoveries_df['Country/Region']==country][i].sum() for i in dates]
    daily_recovery = pd.Series(recoveries).diff().tolist()
    return (cases, deaths, recoveries, daily_increase, daily_death, daily_recovery)

def country_plot(x, y1, y2, y3, y4, country):
    plt.figure(figsize=(16, 9))
    plt.plot(x, y1, linewidth=4)
    plt.title('{} Confirmed Cases'.format(country), size=30)
    plt.ylabel('# of Cases', size=30)
    plt.xticks(size=10)
    plt.xticks(rotation=90)
    plt.yticks(size=20)
    plt.grid(axis='y')
    plt.show()

    plt.figure(figsize=(16, 9))
    plt.bar(x, y2)
    plt.title('{} Daily Increases in Confirmed Cases'.format(country), size=30)
    plt.ylabel('# of Cases', size=30)
    plt.xticks(size=10)
    plt.xticks(rotation=90)
    plt.yticks(size=20)
    plt.grid(axis='y')
    plt.show()

    plt.figure(figsize=(16, 9))
    plt.bar(x, y3, color='darkgoldenrod')
    plt.title('{} Daily Increases in Deaths'.format(country), size=30)
    plt.ylabel('# of Cases', size=30)
    plt.xticks(size=10)
    plt.xticks(rotation=90)
    plt.yticks(size=20)
    plt.grid(axis='y')
    plt.show()

    plt.figure(figsize=(16, 9))
    plt.bar(x, y4, color='green')
    plt.title('{} Daily Increases in Recoveries'.format(country), size=30)
    plt.ylabel('# of Cases', size=30)
    plt.xticks(size=10)
    plt.xticks(rotation=90)
    plt.yticks(size=20)
    plt.grid(axis='y')
    plt.show()

country = 'China'
china_cases, china_deaths, china_recoveries, daily_increase, daily_death,daily_recovery = get_data(country)
country_plot(dates, china_cases, daily_increase, daily_death, daily_recovery, country)

country = 'US'
us_cases, us_deaths, us_recoveries, daily_increase, daily_death,daily_recovery = get_data(country)
country_plot(dates, us_cases, daily_increase, daily_death, daily_recovery, country)

country = 'Italy'
italy_cases, italy_deaths, italy_recoveries, daily_increase, daily_death,daily_recovery = get_data(country)
country_plot(dates, italy_cases, daily_increase, daily_death, daily_recovery, country)

country = 'Spain'
spain_cases, spain_deaths, spain_recoveries, daily_increase, daily_death,daily_recovery = get_data(country)
# country_plot(dates, spain_cases, daily_increase, daily_death, daily_recovery, country)

country = 'France'
france_cases, france_deaths, france_recoveries, daily_increase, daily_death,daily_recovery = get_data(country)
# country_plot(dates, france_cases, daily_increase, daily_death, daily_recovery, country)

country = 'Germany'
germany_cases, germany_deaths, germany_recoveries, daily_increase, daily_death,daily_recovery = get_data(country)
# country_plot(dates, germany_cases, daily_increase, daily_death, daily_recovery, country)

country = 'Philippines'
philippine_cases, philippine_deaths, philippine_recoveries, daily_increase, daily_death,daily_recovery = get_data(country)
country_plot(dates, philippine_cases, daily_increase, daily_death, daily_recovery, country)

# philippine_cases, philippine_deaths, philippine_recoveries, daily_increase, daily_death,daily_recovery
philippine_total_active = (np.array(philippine_cases)-np.array(philippine_deaths)-np.array(philippine_recoveries)).tolist()
philippine_covid_df = pd.DataFrame(
    {'Confirmed': philippine_cases,
     'Deaths'   : philippine_deaths,
     'Recovered': philippine_recoveries,
     'Active'   : philippine_total_active
    }, index=dates_dt)
covid_df.plot(figsize=(16, 9), linewidth=4).grid(axis='y')
plt.title('Philippine Coronavirus Over Time', size=30);

ph_daily_change = philippine_covid_df.diff()
ph_daily_change.Confirmed.plot.bar(figsize=(20, 8), linewidth=4, width=0.8, label='Confirmed Cases', legend=True).grid(axis='y')
ph_daily_change.Active.plot.bar(figsize=(20, 8), linewidth=4, width=0.8, color='firebrick', label='Active', legend=True).grid(axis='y')
ph_daily_change.Recovered.plot.bar(figsize=(20, 8), linewidth=4, width=0.8, color='green', label='Recovered', legend=True).grid(axis='y')
ph_daily_change.Deaths.plot.bar(figsize=(20, 8), linewidth=4, width=0.8, color='darkgoldenrod', label='Deaths', legend=True).grid(axis='y')
plt.title('Philippine COVID-19 Daily Changes', size=30)
plt.xlabel('Days', size=30)
plt.ylabel('# of Cases', size=30);

plt.figure(figsize=(16, 9))
plt.plot(dates, china_cases, 'ro-', markersize=8)
plt.plot(dates, italy_cases, 'gv-', markersize=8)
plt.plot(dates, us_cases, 'bs-', markersize=8)
plt.plot(dates, spain_cases, 'mp-', markersize=8)
plt.plot(dates, france_cases, 'y*-', markersize=8)
plt.plot(dates, germany_cases, 'cd-', markersize=8)
plt.plot(dates, philippine_cases, 'k.-', markersize=8)
plt.title('# of Coronavirus Cases', size=30)
plt.xlabel('Days', size=30)
plt.ylabel('# of Cases', size=30)
plt.legend(['China', 'Italy', 'US', 'Spain', 'France', 'Germany','Philippines'], prop={'size': 20})
plt.xticks(rotation=90)
plt.yticks(size=20)
plt.show()

plt.figure(figsize=(16, 9))
plt.plot(dates, china_deaths, 'ro-', markersize=8)
plt.plot(dates, italy_deaths, 'gv-', markersize=8)
plt.plot(dates, us_deaths, 'bs-', markersize=8)
plt.plot(dates, spain_deaths, 'mp-', markersize=8)
plt.plot(dates, france_deaths, 'y*-', markersize=8)
plt.plot(dates, germany_deaths, 'cd-', markersize=8)
plt.plot(dates, philippine_deaths, 'k.-', markersize=8)
plt.title('# of Coronavirus Deaths', size=30)
plt.xlabel('Days', size=30)
plt.ylabel('# of Cases', size=30)
plt.legend(['China', 'Italy', 'US', 'Spain', 'France', 'Germany','Philippines'], prop={'size': 20})
plt.xticks(rotation=90)
plt.yticks(size=20)
plt.show()

plt.figure(figsize=(16, 9))
plt.plot(dates, china_recoveries, 'ro-', markersize=8)
plt.plot(dates, italy_recoveries, 'gv-', markersize=8)
plt.plot(dates, us_recoveries, 'bs-', markersize=8)
plt.plot(dates, spain_recoveries, 'mp-', markersize=8)
plt.plot(dates, france_recoveries, 'y*-', markersize=8)
plt.plot(dates, germany_recoveries, 'cd-', markersize=8)
plt.plot(dates, philippine_recoveries, 'k.-', markersize=8)
plt.title('# of Coronavirus Recoveries', size=30)
plt.xlabel('Days', size=30)
plt.ylabel('# of Cases', size=30)
plt.legend(['China', 'Italy', 'US', 'Spain', 'France', 'Germany','Philippines'], prop={'size': 20})
plt.xticks(rotation=90)
plt.yticks(size=20)
plt.show()

fig, axs = plt.subplots(6,1, figsize=(15, 64), facecolor='w', edgecolor='k')
fig.subplots_adjust(hspace = .5)
axs = axs.ravel()

ASEAN = ['Indonesia', 'Malaysia', 'Philippines', 'Singapore', 'Thailand', 'Brunei', 'Laos', 'Myanmar', 'Cambodia', 'Vietnam']
 
for country in ASEAN:    
    cases, deaths, recoveries, daily_increase, daily_death, daily_recovery = get_data(country)
    
    axs[0].plot(dates, cases, markersize=8, linewidth=4)
    axs[0].set_title('# of Coronavirus Cases', size=30)
    axs[0].set_xlabel('Days', size=30)
    axs[0].set_ylabel('# of Cases', size=30)
    axs[0].legend(ASEAN, prop={'size': 20}, loc="upper left")
    axs[0].set_xticklabels(dates, rotation=90)

    
    axs[1].plot(dates, deaths, markersize=8, linewidth=4)
    axs[1].set_title('# of Coronavirus Deaths', size=30)
    axs[1].set_xlabel('Days', size=30)
    axs[1].set_ylabel('# of Cases', size=30)
    axs[1].legend(ASEAN, prop={'size': 20}, loc="upper left")
    axs[1].set_xticklabels(dates, rotation=90)


    axs[2].plot(dates, recoveries, markersize=8, linewidth=4)
    axs[2].set_title('# of Coronavirus Recoveries', size=30)
    axs[2].set_xlabel('Days', size=30)
    axs[2].set_ylabel('# of Cases', size=30)
    axs[2].legend(ASEAN, prop={'size': 20}, loc="upper left")
    axs[2].set_xticklabels(dates, rotation=90)

    
    axs[3].plot(dates, daily_increase, markersize=8, linewidth=4)
    axs[3].set_title('# of Coronavirus Daily Increase', size=30)
    axs[3].set_xlabel('Days', size=30)
    axs[3].set_ylabel('# of Cases', size=30)
    axs[3].legend(ASEAN, prop={'size': 20}, loc="upper left")
    axs[3].set_xticklabels(dates, rotation=90)


    axs[4].plot(dates, daily_death, markersize=8, linewidth=4)
    axs[4].set_title('# of Coronavirus Daily Deaths', size=30)
    axs[4].set_xlabel('Days', size=30)
    axs[4].set_ylabel('# of Cases', size=30)
    axs[4].legend(ASEAN, prop={'size': 20}, loc="upper left")
    axs[4].set_xticklabels(dates, rotation=90)

    
    axs[5].plot(dates, daily_recovery, markersize=8, linewidth=4)
    axs[5].set_title('# of Coronavirus Recoveries Daily Increase', size=30)
    axs[5].set_xlabel('Days', size=30)
    axs[5].set_ylabel('# of Cases', size=30)
    axs[5].legend(ASEAN, prop={'size': 20}, loc="upper left")
    axs[5].set_xticklabels(dates, rotation=90)

mean_mortality_rate = np.mean(mortality_rate)
plt.figure(figsize=(16, 9))
plt.plot(dates, mortality_rate, color='orange', linewidth=4)
plt.axhline(y = mean_mortality_rate,linestyle='--', color='black')
plt.title('Mortality Rate of Coronavirus Over Time', size=30)
plt.legend(['mortality rate', 'y='+str(mean_mortality_rate)], prop={'size': 20})
plt.xlabel('Days', size=30)
plt.ylabel('Mortality Rate', size=30)
plt.xticks(rotation=90)
plt.yticks(size=20)
plt.show()

mean_recovery_rate = np.mean(recovery_rate)
plt.figure(figsize=(16, 9))
plt.plot(dates, recovery_rate, color='blue', linewidth=4)
plt.axhline(y = mean_recovery_rate,linestyle='--', color='black')
plt.title('Recovery Rate of Coronavirus Over Time', size=30)
plt.legend(['recovery rate', 'y='+str(mean_recovery_rate)], prop={'size': 20})
plt.xlabel('Days', size=30)
plt.ylabel('Recovery Rate', size=30)
plt.xticks(rotation=90)
plt.yticks(size=20)
plt.show()

plt.figure(figsize=(16, 9))
plt.plot(dates, total_deaths, color='red', linewidth=4)
plt.plot(dates, total_recovered, color='green', linewidth=4)
plt.legend(['death', 'recoveries'], loc='best', fontsize=20)
plt.title('# of Coronavirus Cases', size=30)
plt.xlabel('Days', size=30)
plt.ylabel('# of Cases', size=30)
plt.xticks(rotation=90)
plt.yticks(size=20)
plt.show()

import operator

unique_countries =  list(latest_data['Country_Region'].unique())

country_confirmed_cases = []
country_death_cases = [] 
country_active_cases = []
country_recovery_cases = []
country_mortality_rate = [] 

no_cases = []
for i in unique_countries:
    cases = latest_data[latest_data['Country_Region']==i]['Confirmed'].sum()
    if cases > 0:
        country_confirmed_cases.append(cases)
    else:
        no_cases.append(i)
        
for i in no_cases:
    unique_countries.remove(i)
    
# sort countries by the number of confirmed cases
unique_countries = [k for k, v in sorted(zip(unique_countries, country_confirmed_cases), key=operator.itemgetter(1), reverse=True)]
for i in range(len(unique_countries)):
    country_confirmed_cases[i] = latest_data[latest_data['Country_Region']==unique_countries[i]]['Confirmed'].sum()
    country_death_cases.append(latest_data[latest_data['Country_Region']==unique_countries[i]]['Deaths'].sum())
    country_recovery_cases.append(latest_data[latest_data['Country_Region']==unique_countries[i]]['Recovered'].sum())
    country_active_cases.append(country_confirmed_cases[i] - country_death_cases[i] - country_recovery_cases[i])
    country_mortality_rate.append(country_death_cases[i]/country_confirmed_cases[i])

country_df = pd.DataFrame({'Country Name': unique_countries, 'Number of Confirmed Cases': country_confirmed_cases,
                          'Number of Deaths': country_death_cases, 'Number of Recoveries' : country_recovery_cases, 
                          'Number of Active Cases' : country_active_cases,
                          'Mortality Rate': country_mortality_rate})
# number of cases per country/region

country_df.style.background_gradient(cmap='Greens')

unique_provinces =  list(latest_data['Province_State'].unique())

province_confirmed_cases = []
province_country = [] 
province_death_cases = [] 
province_recovery_cases = []
province_mortality_rate = [] 

no_cases = [] 
for i in unique_provinces:
    cases = latest_data[latest_data['Province_State']==i]['Confirmed'].sum()
    if cases > 0:
        province_confirmed_cases.append(cases)
    else:
        no_cases.append(i)
 
# remove areas with no confirmed cases
for i in no_cases:
    unique_provinces.remove(i)
    
unique_provinces = [k for k, v in sorted(zip(unique_provinces, province_confirmed_cases), key=operator.itemgetter(1), reverse=True)]
for i in range(len(unique_provinces)):
    province_confirmed_cases[i] = latest_data[latest_data['Province_State']==unique_provinces[i]]['Confirmed'].sum()
    province_country.append(latest_data[latest_data['Province_State']==unique_provinces[i]]['Country_Region'].unique()[0])
    province_death_cases.append(latest_data[latest_data['Province_State']==unique_provinces[i]]['Deaths'].sum())
    province_recovery_cases.append(latest_data[latest_data['Province_State']==unique_provinces[i]]['Recovered'].sum())
    province_mortality_rate.append(province_death_cases[i]/province_confirmed_cases[i])

# number of cases per province/state/city
province_df = pd.DataFrame({'Province/State Name': unique_provinces, 'Country': province_country, 'Number of Confirmed Cases': province_confirmed_cases,
                          'Number of Deaths': province_death_cases, 'Number of Recoveries' : province_recovery_cases,
                          'Mortality Rate': province_mortality_rate})
# number of cases per country/region

province_df.style.background_gradient(cmap='Greens')

nan_indices = [] 

# handle nan if there is any, it is usually a float: float('nan')

for i in range(len(unique_provinces)):
    if type(unique_provinces[i]) == float:
        nan_indices.append(i)

unique_provinces = list(unique_provinces)
province_confirmed_cases = list(province_confirmed_cases)

for i in nan_indices:
    unique_provinces.pop(i)
    province_confirmed_cases.pop(i)

china_confirmed = latest_data[latest_data['Country_Region']=='China']['Confirmed'].sum()
outside_mainland_china_confirmed = np.sum(country_confirmed_cases) - china_confirmed
plt.figure(figsize=(16, 9))
plt.barh('Mainland China', china_confirmed)
plt.barh('Outside Mainland China', outside_mainland_china_confirmed)
plt.title('# of Coronavirus Confirmed Cases', size=20)
plt.xticks(size=20)
plt.yticks(size=20)
plt.show()

print('Outside Mainland China: {} cases'.format(outside_mainland_china_confirmed))
print('Mainland China: {} cases'.format(china_confirmed))
print('Total: {} cases'.format(china_confirmed+outside_mainland_china_confirmed))

# Only show 10 countries with the most confirmed cases, the rest are grouped into the other category
visual_unique_countries = [] 
visual_confirmed_cases = []
others = np.sum(country_confirmed_cases[10:])

for i in range(len(country_confirmed_cases[:10])):
    visual_unique_countries.append(unique_countries[i])
    visual_confirmed_cases.append(country_confirmed_cases[i])
    
visual_unique_countries.append('Others')
visual_confirmed_cases.append(others)

def plot_bar_graphs(x, y, title):
    plt.figure(figsize=(16, 9))
    plt.barh(x, y)
    plt.title(title, size=20)
    plt.xticks(size=20)
    plt.yticks(size=20)
    plt.show()

plot_bar_graphs(visual_unique_countries, visual_confirmed_cases, '# of Covid-19 Confirmed Cases in Countries/Regions')

# Only show 10 provinces with the most confirmed cases, the rest are grouped into the other category
visual_unique_provinces = [] 
visual_confirmed_cases2 = []
others = np.sum(province_confirmed_cases[10:])
for i in range(len(province_confirmed_cases[:10])):
    visual_unique_provinces.append(unique_provinces[i])
    visual_confirmed_cases2.append(province_confirmed_cases[i])

visual_unique_provinces.append('Others')
visual_confirmed_cases2.append(others)

plot_bar_graphs(visual_unique_provinces, visual_confirmed_cases2, '# of Coronavirus Confirmed Cases in Provinces/States')

import matplotlib.colors as mcolors


def plot_pie_charts(x, y, title): 
    random.seed(23)
    c = random.choices(list(mcolors.CSS4_COLORS.values()),k = len(unique_countries))
    plt.figure(figsize=(20,15))
    plt.title(title, size=20)
    plt.pie(y, colors=c)
    plt.legend(x, loc='best', fontsize=15)
    plt.show()

plot_pie_charts(visual_unique_countries, visual_confirmed_cases, 'Covid-19 Confirmed Cases per Country')

plot_pie_charts(visual_unique_provinces, visual_confirmed_cases2, 'Covid-19 Confirmed Cases per State/Province/Region')

# Plotting countries with regional data using a pie chart 

def plot_pie_country_with_regions(country_name, title):
    regions = list(latest_data[latest_data['Country_Region']==country_name]['Province_State'].unique())
    confirmed_cases = []
    no_cases = [] 
    for i in regions:
        cases = latest_data[latest_data['Province_State']==i]['Confirmed'].sum()
        if cases > 0:
            confirmed_cases.append(cases)
        else:
            no_cases.append(i)

    # remove areas with no confirmed cases
    for i in no_cases:
        regions.remove(i)

    # only show the top 10 states
    regions = [k for k, v in sorted(zip(regions, confirmed_cases), key=operator.itemgetter(1), reverse=True)]

    for i in range(len(regions)):
        confirmed_cases[i] = latest_data[latest_data['Province_State']==regions[i]]['Confirmed'].sum()  
    
    # additional province/state will be considered "others"
    
    if(len(regions)>10):
        regions_10 = regions[:10]
        regions_10.append('Others')
        confirmed_cases_10 = confirmed_cases[:10]
        confirmed_cases_10.append(np.sum(confirmed_cases[10:]))
        plot_pie_charts(regions_10,confirmed_cases_10, title)
    else:
        plot_pie_charts(regions,confirmed_cases, title)

plot_pie_country_with_regions('US', 'COVID-19 Confirmed Cases in the United States')

plot_pie_country_with_regions('China', 'COVID-19 Confirmed Cases in China')