# %%capture
# !git clone https://github.com/predicthq/phq-data-science-docs.git
# %cd phq-data-science-docs/attended-events
# !pip install predicthq timezonefinder calmap==0.0.9

from predicthq import Client
from timezonefinder import TimezoneFinder
from plotly.subplots import make_subplots
import plotly.graph_objects as go
import plotly.express as px
import folium
from folium.plugins import HeatMap
import numpy as np
import pandas as pd
from datetime import timedelta
import calmap
import rfc3339
import pytz
import calendar
import random

# To display more columns in the dataframe.
pd.set_option("display.max_columns", 50)
%matplotlib inline

# Set whether to run with SDK or using provided CSV files.
# Set to be either "CSV" or "SDK".
RUN_SETTING = "CSV"

if RUN_SETTING == "SDK":
    # Replace Access Token with own access token.
    ACCESS_TOKEN = 'REPLACE_WITH_ACCESS_TOKEN'
    phq = Client(access_token=ACCESS_TOKEN)


def query_attended_events(
    start_time,
    end_time,
    radius,
    radius_unit,
    latitude,
    longitude,
    categories,
    rank_type=None,
    filter_parameter="gte",
    rank_threshold="40",
):
    """
    Query Attended Events based on time, location, category, and rank thresholds.
    Args:
        start_time: start of the period for querying Attended Events.
                    Format "YYYY-MM-DD"
        end_time: end of the period for querying Attended Events.
                  Format of "YYYY-MM-DD"
        radius: radius for querying Attended Events.
        radius_unit: unit of the radius.
        latitude: latitude of the interested location.
        longitude: longitude of the interested location.
        categories: list of categories, such as ["conferences", "expos", "concerts",
                    "festivals", "performing-arts", "sports", "community"].
        rank_type: when it is not None, events are filtered according to rank_type,
                   filter_parameter and rank_threshold. The value could be either
                   "rank", "local_rank" or "aviation_rank".
        filter_parameter: the value could be either "gte", "gt", "lte" or "lt".
                          Note that "lte" or "lt" is not commonly used in practice
                          since we are interested in events with large ranks.
        rank_threshold: the value could be chosen between 0 and 100 depending on the
                        assumption of interested events' sizes.
    return:
        event_df: pandas DataFrame of Attended Events.
    """
    within = f"{radius}{radius_unit}@{latitude},{longitude}"
    timezone = TimezoneFinder().timezone_at(lat=latitude, lng=longitude)

    params = {
        "active__gte": start_time,
        "active__lte": end_time,
        "active__tz": timezone,
        "within": within,
        "category": categories,
        "limit": 500,
    }

    if rank_type is not None:
        params[f"{rank_type}__{filter_parameter}"] = rank_threshold

    result_list = []

    # Iterating through all the events that match our criteria and
    # adding them to our result_list.
    for event in phq.events.search(params).iter_all():
        result_list.append(event.to_dict())

    event_df = pd.DataFrame(result_list)

    # Selecting the target fields.
    event_df = event_df[
        [
            "id",
            "title",
            "category",
            "description",
            "duration",
            "start",
            "end",
            "predicted_end",
            "first_seen",
            "labels",
            "location",
            "place_hierarchies",
            "timezone",
            "entities",
            "phq_attendance",
            "rank",
            "local_rank",
            "aviation_rank",
        ]
    ]

    return event_df

def get_local_dt(dt, tz):
    """
    Localize a datetime for a given timezone.
    Args:
        dt: a datetime in string format.
        tz: timezone to localise to.
    return:
        local_dt: local datetime according to given timezone.
    """
    if not dt:
        return None

    dt = rfc3339.parse_datetime(dt)

    if not tz:
        return dt

    local_dt = dt.astimezone(pytz.timezone(tz))
    return local_dt


def update_end_time(row):
    """
    Update end time if predicted_end is available.
    """
    if isinstance(row["predicted_end"], str):
        return row["predicted_end"]
    else:
        return row["end"]


# Convert to local date and local time of the start of the event.
event_df["start_local"] = event_df.apply(
    lambda row: get_local_dt(row["start"], row["timezone"]), axis=1
)

event_df["start_date"] = event_df.start_local.map(lambda x: x.date())

# Convert to local date and local time at the end of the event.
event_df["end_update"] = event_df.apply(
    lambda row: update_end_time(row),
    axis=1,
)

event_df["end_local"] = event_df.apply(
    lambda row: get_local_dt(row["end_update"], row["timezone"]), axis=1
)

event_df["end_date"] = event_df.end_local.map(lambda x: x.date())

# Convert to local date and local time when the event was seen for the first time.
event_df["first_seen_local"] = event_df.apply(
    lambda row: get_local_dt(row["first_seen"], row["timezone"]), axis=1
)

event_df["first_seen_date"] = event_df.first_seen_local.map(lambda x: x.date())

# Duration of each event in days.
event_df["duration_day"] = event_df.apply(
    lambda row: (row["end_date"] - row["start_date"]).days + 1, axis=1
)

# Duration of each event between the first seen time and start of the event in days.
event_df["day_from_first_seen"] = event_df.apply(
    lambda row: (row["end_date"] - row["first_seen_date"]).days + 1, axis=1
)