import pandas as pd
import geopandas as gpd #used for transforming geolocation data
import matplotlib.pyplot as plt

from datetime import datetime  #to convert data to datetime that does not fall 
#within the pandas.to_datetime function timeframe
from shapely.geometry import Point  #transform latitude/longitude to geo-coordinate data
from geopandas.tools import geocode #get the latitude/longitude for a given address
from geopandas.tools import reverse_geocode  #get the address for a location using latitude/longitude

import requests  #similar to urllib, this library allows a computer to ping a website
import json      #library to handle JSON formatted data
%matplotlib inline

#URL to NASA meteorite API
url = r"https://data.nasa.gov/resource/y77d-th95.json"

#the get function checks to make sure that the website/server is responding back
#200 means that we're good
#https://www.restapitutorial.com/httpstatuscodes.html
resp = requests.get(url)
resp

#send a request to the website to return back text data from the API
#returns data as JSON string
str_data = resp.text
str_data[:1500]

#loads function reversed dictionary order
#dictionary objects are unordered in general
NASAdata = json.loads(str_data)
#NASAdata

#dict['key']['key'][index]
#dictionary name, dictionary key, dictionary key, then list index
NASAdata[0]['geolocation']

type(NASAdata[0]['geolocation'])

NASAdata[0]['geolocation'].keys()

#dict['key']['key'][index]
#dictionary name, dictionary key, dictionary key, then list index
NASAdata[0]['geolocation']['type']

type(NASAdata[0]['geolocation']['type'])

#dict['key']['key'][index]
#dictionary name, dictionary key, dictionary key, then list index
NASAdata[0]['geolocation']['coordinates']

type(NASAdata[0]['geolocation']['coordinates'])

len(NASAdata[0]['geolocation']['coordinates'])

NASAdata[0]['geolocation']['coordinates'][0]

idmls = []
yearls = []
fallls = []
namels = [] 
nametypels = []
massls = []
latitudels = []
longitudels = []

#extract the values for the meteore dataset

for meteor in NASAdata:
      
    #get the value of each key and if the key doesn't exist, set a variable to be None
    try: idm = meteor['id']
    except: idm = None
            
    try: year = meteor['year']
    except: year = None
            
    try: fall = meteor['fall']
    except: fall = None
        
    try: name = meteor['name']
    except: name = None
            
    try: nametype = meteor['nametype']
    except: nametype = None
            
    try: mass = meteor['mass']
    except: mass = None
            
    try: latitude =meteor['geolocation']['coordinates'][1]
    except: latitude = None
            
    try: longitude = meteor['geolocation']['coordinates'][0]
    except: longitude = None
            
    
    idmls.append(idm)
    yearls.append(year)
    fallls.append(fall)
    namels.append(name)  
    nametypels.append(nametype)
    massls.append(mass) 
    latitudels.append(latitude)
    longitudels.append(longitude) 

#check to see first 5 items of a few lists
print(idmls[:5])
print(yearls[:5])
print(fallls[:5])
print(namels[:5])
print(nametypels[:5])
print(massls[:5])

#check number of items in each list
print(len(idmls))
print(len(yearls))
print(len(fallls))
print(len(namels))
print(len(nametypels))
print(len(massls))
print(len(latitudels))
print(len(longitudels))

#match indices of each list and zip into one list
meteorList = list(zip(idmls, yearls, fallls, namels, 
                    nametypels, massls, latitudels, longitudels))

#names for columns in data frame
colnames = ['id', 'year', 'fall','name', 'nametype', 'mass', 'latitude', 'longitude']

#create data frame with column names in it
df = pd.DataFrame(meteorList, columns=colnames)

df.head(10)

df.tail(10)

#take an address and return coordinates
#returned variable is a geo-dataframe with 2 columns, geometry (the geographical shape) and the full physical address
ex1_geo = geocode("1830 Metzerott rd, Adelphi, MD", provider='nominatim')
ex1_geo

#structure of full address
#each API structures addresses differently
ex1_geo['address'].iloc[0]

#use latitude and longitude to get physical address
#pass through using Point geometry
#also returns geo-dataframe with geometry and full physical address
ex2_geo = reverse_geocode([Point(-77.15879730243169, 39.0985195)], provider='nominatim')
ex2_geo

meteor_df = df
meteor_df.head()

#data type of each column
meteor_df.dtypes

#only dataframe with non-null year column values
meteor_df = meteor_df.loc[meteor_df['year'].notnull()]

#change year column into a string
#need to use string type for getYear function below
meteor_df['year'] = meteor_df['year'].astype(str)

#function to split apart the date from the timestamp
def getYear(col):
    #get YYYY-MM-DD value
    date = col.split("T")[0]
    
    #extract year from date
    dt = datetime.strptime(date, '%Y-%m-%d')
    return dt.year

#replace the year timestamp data with only the year (using the getYear function)
meteor_df['year'] = meteor_df['year'].apply(getYear)
meteor_df.head()

#see columns with null values
meteor_df.count()

#only include rows with non-null latitudes (which means longitude is also not null) and non-null mass
meteor_df = meteor_df.loc[(meteor_df['latitude'].notnull()) & meteor_df['mass'].notnull()]
meteor_df.count()

#make a new column to hold the longitude & latitude as a list
meteor_df['coordinates'] = list(meteor_df[['longitude', 'latitude']].values)

#see new coordinates column
meteor_df.head()

#list values in coordinates column is classified as object type
meteor_df['coordinates'].dtypes

#convert the coordinates to a geolocation type
meteor_df['coordinates'] = meteor_df['coordinates'].apply(Point)

#coordinates column now has POINT next to each coordinate pair value
meteor_df.head()

#coordinates column with geolocation data is just a regular pandas Series type
type(meteor_df['coordinates'])

#create a geolocation dataframe type using the coordinates column as the geolocation data
geo_meteor = gpd.GeoDataFrame(meteor_df, geometry='coordinates')

#geo-dataframe looks the same as regular dataframe
geo_meteor.head()

#verify coordinates column is geolocation data type
type(geo_meteor['coordinates'])

#import file that contains a world map shape polygons
#will use to plot the coordinates of meteorite landings
filepath = "datasets/continents.json"

#data contains polygon shape coordinates for different map body types (continents, etc.)
map_df = gpd.read_file(filepath)
map_df.head()

#plot coordinates on top of map graph

#this is to set the size of the borders
fig, ax = plt.subplots(1, figsize=(15,10))

#this is the map 
basemap = map_df.plot(ax=ax,cmap='Greens')

#plot coordinates on top of map graph
geo_meteor.plot(ax=basemap, color='blue', marker="o", markersize=10)

#take off axis numbers
ax.axis('off')

#put title on map
ax.set_title("NASA Meteorite Landings", fontsize=25, fontweight=3)