import requests
import pandas as pd
import numpy as np
import geocoder

import math

# Read in CSV
d = pd.read_csv('atl_neighborhoods.csv')[['NAME','SQMILES']]

### Need to add 'GA' for location search
d['NAME'] = d['NAME'] + ', Atlanta, GA'

custom_radius = []
for ii in range(len(d)):
    #print(d.loc[ii,'SQMILES'])
    custom_radius.append(math.sqrt(d.loc[ii,'SQMILES']/3.14)*1609) #conversion from miles to meters

d['RADIUS'] = custom_radius

print('The custom radius calculation had a minimum distance of {}m and maximum of {}m'.format(min(d['RADIUS']), max(d['RADIUS'])))

d.head()

def get_lat_long(name):
    
    # Returning search for zipcode
    g = geocoder.arcgis(name)
    
    # Latitude
    lati = g.lat
    
    # Longitude
    longi = g.lng
    
    return(lati,longi)

lat_lookup = []
lng_lookup = []

for n in d['NAME']:
    lati,longi = get_lat_long(n)
    
    lat_lookup.append(lati)
    lng_lookup.append(longi)
    
d['LATITUDE'] = lat_lookup
d['LONGITUDE'] = lng_lookup
d.head() 

## Looking at where the locations are
import folium

# create map of New York using latitude and longitude values
map_atl = folium.Map(location=[33.7868002,-84.3970265], zoom_start=10)

# add markers to map
for lat, lng, borough in zip(d['LATITUDE'], d['LONGITUDE'], d['NAME']):
    #label = str(borough)
    #label = folium.Popup(label, parse_html=True)
    folium.CircleMarker(
        [lat, lng],
        radius=5,
        popup=borough,
        color='blue',
        fill=True,
        fill_color='#3186cc',
        fill_opacity=0.7,
        parse_html=False).add_to(map_atl)  
    
map_atl

# Using this function from earlier in the course
def getNearbyVenues(names, latitudes, longitudes, radius):

    venues_list=[]
    for name, lat, lng, rad in zip(names, latitudes, longitudes, radius):
        
            
        # create the API request URL
        url = 'https://api.foursquare.com/v2/venues/explore?&client_id={}&client_secret={}&v={}&ll={},{}&radius={}&limit={}'.format(
            CLIENT_ID, 
            CLIENT_SECRET, 
            VERSION, 
            lat, 
            lng, 
            rad, 
            400)
              
        # make the GET request
        results = requests.get(url).json()['response']['groups'][0]['items']
        
        # return only relevant information for each nearby venue
        venues_list.append([(
            name, 
            lat, 
            lng, 
            v['venue']['name'], 
            v['venue']['location']['lat'], 
            v['venue']['location']['lng'],  
            v['venue']['categories'][0]['name']) for v in results])
    
    nearby_venues = pd.DataFrame([item for venue_list in venues_list for item in venue_list])
    nearby_venues.columns = ['Neighborhood', 
                  'Neighborhood Latitude', 
                  'Neighborhood Longitude', 
                  'Venue', 
                  'Venue Latitude', 
                  'Venue Longitude', 
                  'Venue Category']
    
    return(nearby_venues)

CLIENT_ID = 'XHZAV########' # your Foursquare ID
CLIENT_SECRET = 'FKWR#######' # your Foursquare Secret
VERSION = '20180604'

LIMIT = 100
atl_venues2 = getNearbyVenues(names = d['NAME'],
                             latitudes = d['LATITUDE'],
                             longitudes = d['LONGITUDE'],
                             radius = d['RADIUS'])

atl_venues2.shape

atl_venues2.head()

# getting Counts
counts = atl_venues2.groupby('Neighborhood').count().sort_values('Venue', ascending = False).reset_index()[['Neighborhood','Venue']]
counts.columns = ['Neighborhood','Count']

counts.hist(bins=20)

atl_venues3 = atl_venues2.merge(counts, how = 'left', on = 'Neighborhood')
atl_venues3 = atl_venues3[atl_venues3['Count'] > 10]
atl_venues3.head()

atl_venues3[['Count']].hist()

print('We have reduced our potential neighboorhoods to {} compared to the initial 245'.format(len(atl_venues3['Neighborhood'].unique())))

new_map = atl_venues3[['Neighborhood', 'Neighborhood Latitude', 'Neighborhood Longitude']].groupby('Neighborhood').mean()
new_map = new_map.reset_index()

new_map_atl = folium.Map(location=[33.7868002,-84.3970265], zoom_start=10)

# add markers to map
for lat, lng, borough in zip(new_map['Neighborhood Latitude'], new_map['Neighborhood Longitude'], new_map['Neighborhood']):
    #label = str(borough)
    #label = folium.Popup(label, parse_html=True)
    folium.CircleMarker(
        [lat, lng],
        radius=5,
        popup=borough,
        color='blue',
        fill=True,
        fill_color='#3186cc',
        fill_opacity=0.7,
        parse_html=False).add_to(new_map_atl)  
    
new_map_atl

from sklearn.preprocessing import OneHotEncoder

atl_onehot = pd.get_dummies(atl_venues3['Venue Category'], prefix="", prefix_sep="").drop('Neighborhood', axis = 1)
atl_onehot['Neighborhood'] = atl_venues3['Neighborhood']

fixed_columns = [atl_onehot.columns[-1]] + list(atl_onehot.columns[:-1])
atl_onehot = atl_onehot[fixed_columns]

#atl_onehot.head()

# Getting means for each type
atl_grouped = atl_onehot.groupby('Neighborhood').mean().reset_index()
atl_grouped.head()

import matplotlib.pyplot as plt

coffee_map = atl_grouped[['Neighborhood', 'Coffee Shop']]
coffee_map = coffee_map[coffee_map['Coffee Shop'] > 0].sort_values(by = 'Coffee Shop', ascending = False) 

plt.figure(figsize=(8,6))
plt.bar(coffee_map['Neighborhood'],coffee_map['Coffee Shop'])
plt.xticks(rotation=90)
plt.ylabel('Mean Prevalence of Coffee Shops')
plt.show()

from sklearn.cluster import KMeans

atl_grouped_km = atl_grouped.drop('Neighborhood', axis = 1)

from scipy.spatial.distance import cdist

# k means determine k
distortions = []
K_options = range(1,10)
for k in K_options:
    kmeanModel = KMeans(n_clusters=k).fit(atl_grouped_km)
    kmeanModel.fit(atl_grouped_km)
    distortions.append(sum(np.min(cdist(atl_grouped_km, kmeanModel.cluster_centers_, 'euclidean'), axis=1)) / atl_grouped_km.shape[0])

# Plot the elbow
plt.plot(K_options, distortions, 'bx-')
plt.xlabel('k')
plt.ylabel('Distortion')
plt.title('The Elbow Method showing the optimal k')
plt.show()

kmeans = KMeans(n_clusters=6, random_state=0).fit(atl_grouped_km)

# Adding cluster to data set
atl_grouped['Cluster'] = kmeans.labels_

clust_colors = []
for ii in kmeans.labels_:
    if ii == 0:
       color = 'blue'
    elif ii == 1:
       color = 'red'
    elif ii == 2:
       color = 'green'
    elif ii == 3:
       color = 'orange'
    elif ii == 4:
       color = 'purple'
    else: 
       color = 'grey'
    clust_colors.append(color)
        
new_map['Cluster'] = clust_colors
new_map['Cluster Count'] = kmeans.labels_

# create map of New York using latitude and longitude values
new_map_atl = folium.Map(location=[33.7868002,-84.3970265], zoom_start=12)

# add markers to map
for lat, lng, borough, cluster, num in zip(new_map['Neighborhood Latitude'], new_map['Neighborhood Longitude'], new_map['Neighborhood'], new_map['Cluster'], new_map['Cluster Count']):
    label = str(borough) + ' ' + str(num)
    #label = folium.Popup(label, parse_html=True)
    folium.CircleMarker(
        [lat, lng],
        radius=7,
        popup=label,
        color=cluster,
        fill=True,
        fill_color=cluster,
        fill_opacity=0.7,
        parse_html=False).add_to(new_map_atl)  
    
new_map_atl

cluster_coffee_map = atl_grouped[atl_grouped['Coffee Shop'] > 0].sort_values(by = 'Coffee Shop', ascending = False) 

import seaborn

cluster_group = [0,1,2,3,4,5]
fg = seaborn.FacetGrid(data=cluster_coffee_map, hue='Cluster', hue_order=cluster_group, aspect=4)
fg.map(plt.bar, 'Neighborhood', 'Coffee Shop').add_legend()
fg.set_xticklabels(rotation=90)

perkerson = atl_venues2[atl_venues2['Neighborhood'] == 'Perkerson, Atlanta, GA']
perkerson

atl_grouped['Cluster'] = kmeans.labels_

atl_revised = atl_grouped.loc[(atl_grouped['Cluster'] == 2) | (atl_grouped['Cluster'] ==3)]

def return_most_common_venues(row, num_top_venues):
    row_categories = row.iloc[1:]
    row_categories_sorted = row_categories.sort_values(ascending=False)
    
    return row_categories_sorted.index.values[0:num_top_venues]

num_top_venues = 20

indicators = ['st', 'nd', 'rd']

# create columns according to number of top venues
columns = ['Neighborhood']
for ind in np.arange(num_top_venues):
    try:
        columns.append('{}{} Most Common Venue'.format(ind+1, indicators[ind]))
    except:
        columns.append('{}th Most Common Venue'.format(ind+1))

# create a new dataframe
atl_top_venues = pd.DataFrame(columns=columns)
atl_top_venues['Neighborhood'] = atl_revised['Neighborhood']

for ind in np.arange(atl_revised.shape[0]-1):
    atl_top_venues.iloc[ind, 1:] = return_most_common_venues(atl_grouped.iloc[ind, :-1], num_top_venues)

atl_top_venues['Cluster'] = atl_grouped['Cluster']

coffee_common = []
for ii in range(atl_top_venues.shape[0]):
    present = 0
    for yy in range(1,21):
        if (atl_top_venues.iloc[ii,yy] == 'Coffee Shop') | (atl_top_venues.iloc[ii,yy] == 'Café') | (atl_top_venues.iloc[ii,yy] == 'Tea Room') | (atl_top_venues.iloc[ii,yy] == 'Bakery'):
            present = 1
           
    coffee_common.append(present)
    
    
atl_top_venues['Coffee'] = coffee_common
atl_top_venues.head()        

atl_top_venues[['Cluster', 'Coffee']].groupby('Cluster').mean()

cluster3_neighborhoods = atl_top_venues.loc[(atl_top_venues['Cluster'] == 2) & (atl_top_venues['Coffee'] == 0)].drop('Coffee', axis = 1)

print('We have returned {} neighborhoods which are possible locations'.format(cluster3_neighborhoods.shape[0]))

cluster3_neighborhoods

final_map = cluster3_neighborhoods.merge(new_map, how = 'left', on = 'Neighborhood')

# create map of New York using latitude and longitude values
final_map_atl = folium.Map(location=[33.7868002,-84.3970265], zoom_start=12)

# add markers to map
for lat, lng, borough in zip(final_map['Neighborhood Latitude'], final_map['Neighborhood Longitude'], final_map['Neighborhood']):
    
    if borough == 'Buckhead Village, Atlanta, GA':
        color = 'red'
    elif borough == 'Brookhaven, Atlanta, GA':
        color = 'orange'
    else:
        color = 'blue'
    
    folium.CircleMarker(
        [lat, lng],
        radius=7,
        popup=borough,
        color=color,
        fill=True,
        fill_color=color,
        fill_opacity=0.7,
        parse_html=False).add_to(final_map_atl)  
    
final_map_atl