import numpy as np
from geopy.distance import great_circle

from flaskr.laws import BaseEmissionModel

class EmissionModel(BaseEmissionModel):
    # @abc

    def compute_travel_footprint(
            self,

            origin_latitude,        # degrees
            origin_longitude,       # degrees
            destination_latitude,   # degrees
            destination_longitude,  # degrees

            extra_config=None,

    ):
        footprint = 0.0

        distance = 0.0

        #############################################

        # TODO (?): find closest airport(s) and pick one

        # We're going to need caching here as well.
        from collections import namedtuple
        origin_airport = namedtuple('Position', [
            'latitude',
            'longitude',
            'address',  # perhaps
        ])
        origin_airport.latitude = origin_latitude
        origin_airport.longitude = origin_longitude
        destination_airport = namedtuple('Position', [
            'latitude',
            'longitude',
            'address',  # perhaps
        ])
        destination_airport.latitude = destination_latitude
        destination_airport.longitude = destination_longitude
        #############################################
        #############################################

        # Let's start by computing the distance between the locations

        great_circle_distance = self.get_distance_between(

            origin_latitude=origin_airport.latitude,
            origin_longitude=origin_airport.longitude,
            destination_latitude=destination_airport.latitude,
            destination_longitude=destination_airport.longitude,

        )

        distance += great_circle_distance

        use_train = False
        use_plane = False
        if distance < extra_config['use_train_below_distance']:
            use_train = True
        else:
            use_plane = True

        # I.a Train travel footprint

        if use_train:
            footprint += self.compute_train_footprint(
                distance=great_circle_distance
            )

        # I.b Airplane travel footprint

        elif use_plane:
            footprint += self.compute_airplane_footprint(
                distance=great_circle_distance
            )

        # II.a Double it up since it's a round-trip

        footprint *= 2.0

        distance *= 2.0

        return {

            'distance_km': distance,

            'co2eq_kg': footprint,

            'train_trips': 1 if use_train else 0,  # amount of round trips
            'plane_trips': 1 if use_plane else 0,  # amount of round trips

        }

    def compute_train_footprint(self, distance):

        gcd_to_road_correction = self.shared_config.gcd_to_road_scale
        train_emission = self.shared_config.train_emission  # kg/km

        return gcd_to_road_correction * distance * train_emission

    def compute_airplane_footprint(
            self,

            distance

    ):
        config = self.config.plane_emission_linear_fit

        distance = config.connecting_flights_scale * distance

        footprint = self.compute_airplane_distance_footprint(distance, config)

        return footprint

    def compute_airplane_distance_footprint(self, distance, config=None):

        """
        :param distance: in km
        :param config:
        :return:
        """

        if config is None:
            config = self.config.plane_emission_linear_fit
        distance = distance * config.scale_before + config.offset_before
        footprint = self.apply_scaling_law(distance, config)

        # We can totally ignore RFI in config by commenting the line below

        footprint = self.adjust_footprint_for_rfi(footprint, config)

        return footprint

    def adjust_footprint_for_rfi(self, footprint, config):

        return config.rfi * footprint

    def apply_scaling_law(self, distance, config):

        """
        :param distance: in km
        :param config:

        :return: float

        """

        footprint = distance

        for interval in config.intervals:

            if interval.dmin <= distance < interval.dmax:
                offset = interval.offset if interval.offset else 0
                scale = interval.scale if interval.scale else 1
                footprint = footprint * scale + offset
                break

        return footprint

    def get_distance_between(
            self,

            origin_latitude,
            origin_longitude,
            destination_latitude,
            destination_longitude
    ):

        """
        :param origin_latitude:
        :param origin_longitude:
        :param destination_latitude:
        :param destination_longitude:

        :return: Distance in kilometers between the two locations,

                 along Earth's great circles.
        """

        return great_circle(

            (np.float(origin_latitude), np.float(origin_longitude)),
            (np.float(destination_latitude), np.float(destination_longitude))

        ).kilometers