# python
from datetime import datetime
from functools import partial
import sys

# pypi
from expects import equal, expect
from tabulate import tabulate

import altair
import geopandas
import pandas

from graeae.visualization.altair_helpers import output_path, save_chart

print(sys.version)

print(altair.__version__)

TABLE = partial(tabulate, headers="keys", showindex=False, tablefmt="orgtbl")

SLUG = "nyc-shootings-python-version"
OUTPUT_PATH = output_path(SLUG)
save_it = partial(save_chart, output_path=OUTPUT_PATH, height=650)

URL = "https://data.cityofnewyork.us/api/views/833y-fsy8/rows.csv?accessType=DOWNLOAD"
data = pandas.read_csv(URL)

rows, columns = data.shape
print(f"Rows: {rows:,}\tColumns: {columns}")

print(TABLE(data.describe(), showindex=True))

missing = len(data) - data.count()
missing = missing.reset_index().rename(
    columns={"index": "Column",
	     0: "Missing"})

some_missing = missing[missing.Missing > 0].copy()
some_missing.loc[:, "Fraction"] = some_missing.Missing/len(data)
print(TABLE(some_missing))

indexed = data.set_index(DATE_COLUMN)
monthly = indexed.groupby(pandas.Grouper(freq="M"))
monthly_counts = monthly.count()["INCIDENT_KEY"].reset_index().rename(
    columns={"INCIDENT_KEY": "Shootings",
	     "date_time": "Month"}
)
expect(monthly_counts["Shootings"].sum()).to(equal(len(data)))

MONTH_YEAR = "%B %Y"
chart = altair.Chart(monthly_counts).mark_line(
    point={"filled": False,
	   "fill": "white"}).encode(
    x=altair.X("Month", type="temporal"),
    y=altair.Y("Shootings"),
    tooltip=[altair.Tooltip("Month", format=MONTH_YEAR),
	     altair.Tooltip("Shootings")]
).properties(
    width=800,
    height=525,
    title="NYC Shootings By Month"
)

save_it(chart, "monthly_incidents")

monthly_counts["Rolling Mean"] = monthly_counts["Shootings"].ewm(
    halflife="90 days", times=monthly_counts.Month).mean()
pre_melt = monthly_counts.rename(columns={"Shootings": "Sum"})
melted = pre_melt.melt("Month", var_name="Aggregation", value_name="Aggregated Value")
chart = altair.Chart(melted).mark_line(
    point={"filled": False,
	   "fill": "white"}).encode(
	       x=altair.X("Month"),
	       y=altair.Y("Aggregated Value"),
	       color="Aggregation",
	       tooltip=[altair.Tooltip("Month", format=MONTH_YEAR),
			altair.Tooltip("Aggregated Value")]
).properties(
    width=800,
    height=525,
    title="NYC Shootings By 90 Day Exponential Weighted Mean"
)

save_it(chart, "monthly_rolling_incidents")

yearly = indexed.groupby(pandas.Grouper(freq="Y"))
yearly_counts = yearly.count()["INCIDENT_KEY"].reset_index().rename(
    columns={"INCIDENT_KEY": "Shootings"}
)

yearly_counts["Year"] = yearly_counts.date_time.dt.year
expect(yearly_counts["Shootings"].sum()).to(equal(len(data)))

chart = altair.Chart(yearly_counts).mark_line(
    point={"filled": False,
	   "fill": "white"}).encode(
    x=altair.X("Year", type="ordinal"),
    y=altair.Y("Shootings"),
    tooltip=[altair.Tooltip("Year"),
	     altair.Tooltip("Shootings", format=",")]
).properties(
    width=800,
    height=525,
    title="NYC Shootings By year"
)

save_it(chart, "yearly_incidents")

monthly_counts = monthly.count()["INCIDENT_KEY"].reset_index().rename(
    columns={"INCIDENT_KEY": "Shootings"}
)
# monthly_counts = monthly_counts.rename(columns={"Month": "date-time"})

month_map = dict(zip(range(1, 13), "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split()))
monthly_counts["Year"] = monthly_counts["date_time"].dt.year
monthly_counts["Month"] = monthly_counts["date_time"].dt.month.apply(lambda month: month_map[month])

selection = altair.selection_point(fields=["Year"],
				   bind="legend")

chart = altair.Chart(monthly_counts).mark_line(
    point={"filled": False,
	   "fill": "white"}).encode(
    x=altair.X("Month",
	       sort=monthly_counts["date_time"].values),
    y=altair.Y("Shootings"),
    color=altair.Color("Year", type="nominal"),
    tooltip=[altair.Tooltip("date_time", title="Month", format=MONTH_YEAR),
	     altair.Tooltip("Shootings")],
    opacity=altair.condition(selection,
			     altair.value(0.8),
			     altair.value(0.2))
).properties(
    width=800,
    height=525,
    title="NYC Monthly Shootings By year"
).add_params(selection)

save_it(chart, "month_year_shootings")

by_month_median = monthly_counts.groupby("Month").median().reset_index()

chart = altair.Chart(by_month_median).mark_bar().encode(
    x=altair.X("Month", sort=list(month_map.values())),
    y="Shootings",
    tooltip=[altair.Tooltip("Month"),
	     altair.Tooltip("Shootings"),]
).properties(
    width=800,
    height=525,
    title="NYC Median Shootings By Month (2006 through 2012)"
)

save_it(chart, "monthly_shootings")

path_to_data = geopandas.datasets.get_path("nybb")
nyc_geopandas = geopandas.read_file(path_to_data)

print(nyc_geopandas.head(1))

BOROUGH_COLUMN = "BoroName"
SHOOTINGS_COLUMN = "Shootings"
latest = data[data.date_time.dt.year==2021]
latest_count = latest.groupby("BORO").count().reset_index()
expect(latest_count.INCIDENT_KEY.sum()).to(equal(len(latest)))
latest_count = latest_count.rename(columns=dict(BORO=BOROUGH_COLUMN))
latest_count[BOROUGH_COLUMN] = latest_count[BOROUGH_COLUMN].str.title()
latest_count[SHOOTINGS_COLUMN] = latest_count["INCIDENT_KEY"].copy()
latest_count = latest_count[[BOROUGH_COLUMN, SHOOTINGS_COLUMN]]
merged = nyc_geopandas.merge(latest_count, on=BOROUGH_COLUMN)

merged = merged[[BOROUGH_COLUMN, SHOOTINGS_COLUMN, "geometry"]]
explorer = merged.explore(column=SHOOTINGS_COLUMN,
			  tooltip=BOROUGH_COLUMN,
			  popup=True)
explorer.save(f"{OUTPUT_PATH}/nyc-shootings-explore.html")

MURDER_FLAG = "STATISTICAL_MURDER_FLAG"
MURDERED = "Murdered"
BOROUGH = "Borough"
YEAR = "Year"
data[YEAR] = data.date_time.dt.to_period("Y").dt.to_timestamp()
yearly_murders = data.groupby([YEAR, "BORO"]).sum(
    MURDER_FLAG).reset_index().rename(
	columns={
	    "BORO": BOROUGH,
	    MURDER_FLAG: MURDERED})
yearly_murders = yearly_murders[[YEAR, BOROUGH, MURDERED]]

SELECTION = altair.selection_point(fields=[BOROUGH], bind="legend")

chart = altair.Chart(yearly_murders).mark_line(
    point={"filled": False,
	   "fill": "white"}).encode(
	       x=altair.X(YEAR),
	       y=altair.Y(MURDERED),
	       color=BOROUGH,
	       tooltip=[altair.Tooltip(YEAR),
			altair.Tooltip(MURDERED),
			altair.Tooltip(BOROUGH)],
	       opacity=altair.condition(SELECTION,
					altair.value(0.8),
					altair.value(0.2))
	   ).add_params(SELECTION).properties(
	       width=800,
	       height=525,
	       title="NYC Murders By Year"
	   )

save_it(chart, "yearly_borough_murders")
#+end_src

MONTH = "Month"
data[MONTH] = data.date_time.dt.to_period("M").dt.to_timestamp()
murdered = data.groupby([MONTH, "BORO"]).sum(MURDER_FLAG).reset_index()
murdered = murdered[[MONTH, "BORO", MURDER_FLAG]].rename(columns={
    "BORO": BOROUGH,
    MURDER_FLAG: MURDERED,    
})

SELECTION = altair.selection_point(fields=[BOROUGH], bind="legend")

chart = altair.Chart(murdered).mark_line(
    point={"filled": False,
	   "fill": "white"}).encode(
	       x=altair.X(MONTH),
	       y=altair.Y(MURDERED),
	       color=BOROUGH,
	       tooltip=[altair.Tooltip(MONTH, format=MONTH_YEAR),
			altair.Tooltip(MURDERED),
			altair.Tooltip(BOROUGH)],
	       opacity=altair.condition(SELECTION,
					altair.value(0.8),
					altair.value(0.2))
	   ).add_params(SELECTION).properties(
	       width=800,
	       height=525,
	       title="NYC Murders By Month"
	   )

save_it(chart, "monthly_borough_murders")

murdered = data[data[MURDER_FLAG]]

murder_coordinates = murdered[["BORO", "date_time",
			       "Longitude", "Latitude"
			       ]].rename(columns=dict(
				   BORO="Borough",
			       ))
murder_coordinates["Year"] = murder_coordinates.date_time.dt.year

chart = (altair.Chart(murder_coordinates)
	 .mark_point(opacity=0.2)
	 .encode(
	     x=altair.X("Longitude").scale(
		 domain=(murder_coordinates["Longitude"].min(),
			 murder_coordinates["Longitude"].max())),
	     y=altair.Y("Latitude").scale(
		 domain=(murder_coordinates["Latitude"].min(),
			 murder_coordinates["Latitude"].max())),
	     color="Borough",
	     tooltip=[altair.Tooltip("Borough"),
		      altair.Tooltip("date_time")],
	 ).properties(
	     width=800,
	     height=525,
	     title="Murders By Longitude, Latitude and Year",
    ).add_params(select_year)
	 .transform_filter(select_year))

save_it(chart, "murders-by-coordinates-and-year")

# python
from collections import namedtuple

# pypi
from attrs import define
from expects import contain_only, equal, expect

Direction = namedtuple("Direction", ["up_left", "up", "left"],
		       defaults=["\\", "|", "-"])()

@define
class LongestCommonSubsequence:
    """Finds the longest common subsequence of two sequences

    Args:
     x: first sequence
     y: second sequence
    """
    x: list
    y: list
    _table: list=None
    _trace_table: list=None
    _length: int=None

    @property
    def table(self) -> list:
	"""The memoization table"""
	if self._table is None:
	    self._table = [[0] + [None] * len(self.y)
			   for row in range(len(self.x) + 1)]
	    for column in range(len(self.y) + 1):
		self._table[0][column] = 0
	return self._table

    @property
    def trace_table(self) -> list:
	"""Table to reconstruct longest common subsequence"""
	if self._trace_table is None:
	    self._trace_table = [[None] * len(self.y)
				 for row in range(len(self.x))]
	return self._trace_table

    @property
    def length(self) -> int:
	"""Number of characters in longest common subsequence"""
	if self._length is None:
	    for row in range(1, len(self.x) + 1):
		for column in range(1, len(self.y) + 1):
		    previous_row, previous_column = row - 1, column - 1
		    unpadded_row, unpadded_column = row - 1, column - 1
		    if self.x[previous_row] == self.y[previous_column]:
			self.table[row][column] = self.table[previous_row][previous_column] + 1
			self.trace_table[unpadded_row][unpadded_column] = Direction.up_left
		    elif self.table[previous_row][column] >= self.table[row][previous_column]:
			self.table[row][column] = self.table[previous_row][column]
			self.trace_table[unpadded_row][unpadded_column] = Direction.up
		    else:
			self.table[row][column] = self.table[row][previous_column]
			self.trace_table[unpadded_row][unpadded_column] = Direction.left
	    self._length = self.table[-1][-1]
	return self._length

    def print_lcs(self, row: int, column: int) -> None:
	"""Prints the elements of the longest common subsequence

	Note:
	 to start row and column should match the last cell in the trace table.

	Args:
	 row: row in the trace_table to start with
	 column: column in the trace_table to start with
	"""
	if row < 0 or column < 0:
	    return

	if self.trace_table[row][column] == Direction.up_left:
	    self.print_lcs(row - 1, column - 1)
	    print(self.x[row])
	elif self.trace_table[row][column] == Direction.up:
	    self.print_lcs(row - 1, column)
	else:
	    self.print_lcs(row, column - 1)
	return

    def print_longest(self):
	self.print_lcs(len(self.trace_table) - 1, len(self.trace_table[0]) - 1)
	return

x = "A B C B D A B".split()
y = "B D C A B A".split()
lcs = LongestCommonSubsequence(x, y)

expect(len(lcs.table)).to(equal(len(x) + 1))
expect(len(lcs.table[0])).to(equal(len(y) + 1))
for row in lcs.table:
    expect(row[0]).to(equal(0))

expect(lcs.table[0]).to(contain_only(*([0] * (len(y) + 1))))
expect(len(lcs.trace_table)).to(equal(len(x)))
expect(len(lcs.trace_table[0])).to(equal(len(y)))
expect(lcs.length).to(equal(4))

gallons_per_dollar = Fraction(1, 5)
joules_per_gallon = 13 * 10**7
joules_per_dollar = joules_per_gallon * gallons_per_dollar
MEGAJOULES_PER_JOULE = Fraction(1, 10**6)
gas_megajoules_per_dollar = joules_per_dollar * megajoules_per_joule
gasoline = 1/gas_megajoules_per_dollar

print_energy(float(gas_megajoules_per_dollar), "Gasoline")
COSTS.append((gasoline, "Gasoline"))

kilowatt_hours_per_dollar = 20 # 1/0.05 = 20
megajoules = 3.6
electricity_megajoules_per_dollar = kilowatt_hours_per_dollar * megajoules
electricity = 1/electricity_megajoules_per_dollar

print_energy(electricity_megajoules_per_dollar, "Electricity")
COSTS.append((electricity, "Electricity"))

joules_per_cubic_foot = 1.1E6
cubic_feet_per_btu = 1/1030
btus_per_dollar = 5e5

joules_per_btu = joules_per_cubic_foot * cubic_feet_per_btu

joules_per_dollar = joules_per_btu * btus_per_dollar
natural_gas_megajoules_per_dollar = joules_per_dollar * MEGAJOULES_PER_JOULE
natural_gas = 1/natural_gas_megajoules_per_dollar
print_energy(natural_gas_megajoules_per_dollar, "Natural Gas")
COSTS.append((natural_gas, "Natural Gas"))

coal_megajoules_per_dollar = MEGAJOULES_PER_JOULE * 3.2e10/40
coal = 1/coal_megajoules_per_dollar
print_energy(coal_megajoules_per_dollar, "Coal")
COSTS.append((coal, "Coal"))

ounces_per_dollar = 1/0.10
kilocalories_per_ounce = 240
joules_per_calorie = 4.2
calories_per_kilocalorie = 10**3

corn_megajoules_per_dollar = (ounces_per_dollar
			      * kilocalories_per_ounce
			      * calories_per_kilocalorie
			      * joules_per_calorie
			      * MEGAJOULES_PER_JOULE)
corn = 1/corn_megajoules_per_dollar
print_energy(corn_megajoules_per_dollar, "Corn")
COSTS.append((corn, "Corn"))