Utils

class AgriquestBlocks(Enum):
    """
    Available AgriQuest Block codes
    """
    FIRST_LEVEL = 129
    AMU_AUSTRALIA_LEVEL_1 = 205
    AMU_AUSTRALIA_LEVEL_2 = 206
    AMU_CHINA = 202
    AMU_EUROPE_RUSSIA = 197
    AMU_INDIA = 204
    AMU_MEXICO = 212
    AMU_NORTH_AMERICA = 207
    AMU_SOUTH_AFRICA = 213
    BM_REGIONS = 139
    CAR = 140
    COUNTY = 141
    FRA_CANTONS = 216
    FRA_COMMUNES = 135
    FRA_DEPARTEMENTS = 226
    MESOREGION = 131
    NORTH_AFRICA_AMU = 125
    RAION = 127
    SERBIA = 132
    SOUTH_AMERICA_MUNICIPIOS_2020 = 267
    SOUTH_AMERICA_AMU = 115
    SPAIN_COMARCAS = 136
    US_ASD = 130
    WESTERN_AFRICA_AMU = 122

class AgriquestCommodityCode(Enum):
    """
    Available AgriQuest Commodity values
    """
    ALL_VEGETATION = 33
    ALL_CROPS = 35

class AgriquestFranceBlockCode(Enum):
    """
    Available AgriQuest Block codes dedicated to France
    """
    FRA_CANTONS = 216
    FRA_COMMUNES = 135
    FRA_DEPARTEMENTS = 226

class AgriquestWeatherType(Enum):
    """
    Available AgriQuest Weather types
    """
    CUMULATIVE_PRECIPITATION = "cumulative-precipitation"
    MIN_TEMPERATURE = "min-temperature"
    AVERAGE_TEMPERATURE = "average-temperature"
    MAX_TEMPERATURE = "max-temperature"
    MAX_WIND_SPEED = "max-wind-speed"
    RELATIVE_HUMIDITY = "relative-humidity"
    SNOW_DEPTH = "snow-depth"
    SOIL_MOISTURE = "soil-moisture"
    SOLAR_RADIATION = "solar-radiation"

class CropIdSeason(Enum):
    """
    Available season values  for analytics processor Zarc
    """
    SEASON_1="SEASON_1"
    SEASON_2="SEASON_2"

class Emergence(Enum):
    """
    Type of Emergence query used for Emergence analytics processor
    """
    EMERGENCE_IN_SEASON = "IN_SEASON"
    EMERGENCE_HISTORICAL = "HISTORICAL"
    EMERGENCE_DELAY = "DELAY"

class Env(Enum):
    """
    Environment to target (PROD, PREPROD)
    """
    PROD = "prod"
    PREPROD = "preprod"

class GeosysApiEndpoints(Enum):
    """
    Available Geosys APIs Endpoints
    """
    MASTER_DATA_MANAGEMENT_ENDPOINT = "master-data-management/v6"
    VTS_ENDPOINT = "vegetation-time-series/v1/season-fields"
    VTS_BY_PIXEL_ENDPOINT = "vegetation-time-series/v1/season-fields/pixels"
    FLM_CATALOG_IMAGERY = "field-level-maps/v4/season-fields/{}/catalog-imagery"
    FLM_COVERAGE = "field-level-maps/v4/season-fields/{}/coverage"
    WEATHER_ENDPOINT = "Weather/v1/weather"
    ANALYTICS_FABRIC_ENDPOINT = "analytics/metrics"
    ANALYTICS_FABRIC_LATEST_ENDPOINT = "analytics/metrics-latest"
    ANALYTICS_FABRIC_SCHEMA_ENDPOINT = "analytics/schemas"
    AGRIQUEST_ENDPOINT = "agriquest/Geosys.Agriquest.CropMonitoring.WebApi/v0/api"
    # Analytics processor
    PROCESSOR_EVENTS_ENDPOINT = "analytics-pipeline/v1/processors/events"
    LAUNCH_PROCESSOR_ENDPOINT = "analytics-pipeline/v1/processors/{}/launch"

class Harvest(Enum):
    """
    Type of Harvest query used for Harvest analytics processor
    """
    HARVEST_IN_SEASON = "IN_SEASON"
    HARVEST_HISTORICAL = "HISTORICAL"

class Region(Enum):
    """
    Region to target (NA)
    """
    NA = "na"

class SatelliteImageryCollection(Enum):
    """
    Available imagery collections
    """
    MODIS = "MODIS"
    SENTINEL_2 = "SENTINEL_2"
    LANDSAT_8 = "LANDSAT_8"
    LANDSAT_9 = "LANDSAT_9"

class WeatherTypeCollection(Enum):
    """
    Available weather collections
    """
    WEATHER_FORECAST_DAILY = "FORECAST_DAILY"
    WEATHER_FORECAST_HOURLY = "FORECAST_HOURLY"
    WEATHER_HISTORICAL_DAILY = "HISTORICAL_DAILY"

class ZarcCycleType(Enum):
    """
    Available season values  for analytics processor Zarc
    """
    CYCLE_TYPE_1 = "1"
    CYCLE_TYPE_2 = "2"
    CYCLE_TYPE_3 = "3"
    NONE = None

class ZarcSoilType(Enum):
    """
    Available Soil Type values for analytics processor Zarc
    """
    SOIL_TYPE_1 = "1"
    SOIL_TYPE_2 = "2"
    SOIL_TYPE_3 = "3"
    NONE = None

class Helper:

    @staticmethod
    def get_matched_str_from_pattern(pattern: str,
                                     text: str) -> str:
        """Returns the first occurence of the matched pattern in text.

        Args:
            pattern : A string representing the regex pattern to look for.
            text : The text to look into.

        Returns:
            A string representing the first occurence in text of the pattern.

        """
        p = re.compile(pattern)
        return p.findall(text)[0]

    @staticmethod
    def convert_to_wkt(geometry):
        """ convert a geometry (WKT or geoJson) to WKT
        Args:
            geometry : A string representing the geometry (WKT or geoJson)

        Returns:
            a valid WKT

        """

        try:
            # check if the geometry is a valid WKT
            if Helper.is_valid_wkt(geometry):
                # return the wkt
                return geometry
        except:
            try:
                # check if the geometry is a valid geoJson
                geojson_data = json.loads(geometry)
                geom = shape(geojson_data)
                geometry = geom.wkt

                return geometry

            except ValueError:
                # geometry is not a valid geoJson
                return None

    @staticmethod
    def is_valid_wkt(geometry):
        """ check if the geometry is a valid WKT
        Args:
            geometry : A string representing the geometry

        Returns:
            boolean (True/False)

        """
        try:
            wkt.loads(geometry)
            return True
        except ValueError:
            return False

class HttpClient:

    def __init__(
            self,
            client_id: str,
            client_secret: str,
            username: str,
            password: str,
            enum_env: str,
            enum_region: str,
            bearer_token: str = None
    ):
        self.__client_oauth = oauth2_client.Oauth2Api(
            client_id=client_id,
            client_secret=client_secret,
            password=password,
            username=username,
            enum_env=enum_env,
            enum_region=enum_region,
            bearer_token=bearer_token
        )
        self.access_token = self.__client_oauth.token

        self.__client = OAuth2Session(self.__client_oauth.client_id, token=self.__client_oauth.token)

    @renew_access_token
    def get(self, url_endpoint: str, headers={}):
        """Gets the url_endpopint.

        Args:
            url_endpoint : A string representing the url to get.

        Returns:
            A response object.
        """
        return self.__client.get(url_endpoint, headers=headers)

    @renew_access_token
    def post(self, url_endpoint: str, payload: dict, headers={}):
        """Posts payload to the url_endpoint.

        Args:
            url_endpoint : A string representing the url to post paylaod to.
            payload : A python dict representing the payload.

        Returns:
            A response object.
        """
        return self.__client.post(url_endpoint, json=payload, headers=headers)

    @renew_access_token
    def patch(self, url_endpoint: str, payload: dict):
        """Patchs payload to the url_endpoint.

        Args:
            url_endpoint : A string representing the url to patch paylaod to.
            payload : A python dict representing the payload.

        Returns:
            A response object.
        """
        return self.__client.patch(url_endpoint, json=payload)

    def get_access_token(self):
        return self.access_token

class Oauth2Api:
    def __init__(
            self,
            client_id: str,
            client_secret: str,
            username: str,
            password: str,
            enum_env: str,
            enum_region: str,
            bearer_token: str = None
    ):
        """Initializes a Geosys instance with the required credentials
        to connect to the GEOSYS API.
        """
        self.logger = logging.getLogger(__name__)
        self.client_id = client_id
        self.server_url = geosys_platform_urls.IDENTITY_URLS[enum_region][enum_env]
        self.client_secret = client_secret
        self.token = None
        self.username = username
        self.password = password

        if bearer_token:
            self.token = {"access_token": bearer_token}
        else:
            self.__authenticate()

    def __authenticate(self):
        """Authenticates the http_client to the API.

        This method connects the user to the API which generates a token that
        will be valid for one hour. A refresh token is also generated, which
        makes it possible for the http methods wrappers to get a new token
        once the previous one is no more valid through the renew_access_token
        decorator. This method is only run once when a Geosys object is instantiated.

        """

        try:
            oauth = OAuth2Session(
                client=LegacyApplicationClient(client_id=self.client_id)
            )
            self.token = oauth.fetch_token(
                token_url=self.server_url,
                username=self.username,
                password=self.password,
                client_id=self.client_id,
                client_secret=self.client_secret,
            )
            self.token["refresh_token"] = oauth.cookies["refresh_token"]
            self.logger.info("Authenticated")
        except Exception as e:
            logging.error(e)

    def get_refresh_token(self):
        """Fetches a new token."""
        client = OAuth2Session(self.client_id, token=self.token)
        return client.refresh_token(
            self.server_url,
            client_id=self.client_id,
            client_secret=self.client_secret,
        )