# Licensed under a 3-clause BSD style license - see LICENSE.rst


import functools
import numpy as np
from astropy.table import Table

from ..query import BaseQuery
from ..utils import commons, async_to_sync

from . import conf

__all__ = ['Ogle', 'OgleClass']

__doctest_skip__ = ['OgleClass.*']


def _validate_params(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        algorithm = kwargs.get('algorithm')
        quality = kwargs.get('quality')
        coord_sys = kwargs.get('coord_sys')
        # if unspecified, the defaults (which are OK) will be used
        if algorithm is not None and algorithm not in Ogle.algorithms:
            raise ValueError("'algorithm` must be one of \
                             {!s}".format(Ogle.algorithms))
        if quality is not None and quality not in Ogle.quality_codes:
            raise ValueError("'quality' must be one of \
                             {!s}".format(Ogle.quality_codes))
        if coord_sys is not None and coord_sys not in Ogle.coord_systems:
            raise ValueError("'coord_sys' must be one of \
                    {!s}".format(Ogle.coord_systems))
        return func(*args, **kwargs)
    return wrapper


class CoordParseError(ValueError):

    def __init__(self, message='Could not parse `coord` argument.', **kwargs):
        super().__init__(message, **kwargs)


@async_to_sync
class OgleClass(BaseQuery):

    DATA_URL = conf.server
    TIMEOUT = conf.timeout

    algorithms = ['NG', 'NN']
    quality_codes = ['GOOD', 'ALL']
    coord_systems = ['RD', 'LB']

    @_validate_params
    def query_region_async(self, *, coord=None, algorithm='NG', quality='GOOD',
                           coord_sys='RD', get_query_payload=False):
        """
        Query the OGLE-III interstellar extinction calculator.

        Parameters
        ----------
        coord : list-like
            Pointings to evaluate interstellar extinction. Three forms of
            coordinates may be passed::

                * single astropy coordinate instance
                * list-like object (1 x N) of astropy coordinate instances

        algorithm : string
            Algorithm to interpolate data for desired coordinate.
            Valid options::

                * 'NG': nearest grid point
                * 'NN': natural neighbor interpolation

        quality : string
            Quality factor for data. Valid options::

                * 'All': all points
                * 'GOOD': QF=0 as described in Nataf et al. (2012).

        coord_sys : string
            Coordinate system if using lists of RA/Decs in ``coord``.
            Valid options::

                * 'RD': equatorial coordinates
                * 'LB': Galactic coordinates.

        get_query_payload : bool, optional
            If `True` then returns the generated query payload.
            Defaults to `False`.

        Returns
        -------
        response : `requests.Response`
            The HTTP response returned from the service.

        Raises
        ------
        CoordParseError
            Exception raised for malformed coordinate input

        Examples
        --------
        Using astropy coordinates:

        >>> from astropy.coordinates import SkyCoord
        >>> from astropy import units as u
        >>> co = SkyCoord(0.0, 3.0, unit=(u.degree, u.degree),
        ...               frame='galactic')
        >>> from astroquery.ogle import Ogle
        >>> t = Ogle.query_region(coord=co)
        >>> t.pprint()
        RA/LON   Dec/Lat    A_I  E(V-I) S_E(V-I) R_JKVI   mu    S_mu
        --------- ---------- ----- ------ -------- ------ ------ ----- ...
        17.568157 -27.342475 3.126  2.597    0.126 0.3337 14.581 0.212
        """
        # Determine the coord object type and generate list of coordinates
        lon, lat = self._parse_coords(coord, coord_sys)
        # Generate payload
        query_header = '# {0} {1} {2}\n'.format(coord_sys, algorithm, quality)
        sources = '\n'.join(['{0} {1}'.format(lo, la) for lo, la in
                             zip(lon, lat)])
        file_data = query_header + sources
        files = {'file1': file_data}
        if get_query_payload:
            return files
        # Make request
        params = {'dnfile': 'submit'}
        response = self._request("POST", url=self.DATA_URL, data=params,
                                 timeout=self.TIMEOUT, files=files)

        response.raise_for_status()
        return response

    def _parse_result(self, response, *, verbose=False):
        # Header is in first row starting with #, this works with the default
        t = Table.read(response.text.split('\n'), format='ascii')
        return t

    def _parse_coords(self, coord, coord_sys):
        """
        Parse single astropy.coordinates instance, list of astropy.coordinate
        instances, or 2xN list of coordinate values.

        Parameters
        ----------
        coord : list-like
        coord_sys : string

        Returns
        -------
        lon : list
            Longitude coordinate values
        lat : list
            Latitude coordinate values
        """
        if not isinstance(coord, list):
            # single astropy coordinate
            try:
                ra, dec = commons.coord_to_radec(coord)
                lon = [ra]
                lat = [dec]
                return lon, lat
            except ValueError:
                raise CoordParseError()
        elif isinstance(coord, list):
            shape = np.shape(coord)
            # list of astropy coordinates
            if len(shape) == 1:
                try:
                    radec = [commons.coord_to_radec(co) for co in coord]
                    lon, lat = list(zip(*radec))
                    return lon, lat
                except ValueError:
                    raise CoordParseError()
            else:
                raise CoordParseError()
        else:
            raise CoordParseError()

    def _parse_raw(self, raw_data):
        """
        Parse the raw strings returned from the query request and return a list
        of lists for each column in string format.

        Parameters
        ----------
        raw_data : list
            Raw data from the request formatted to as list of strings for each
            line

        Returns
        -------
        data : list
            List of lists for each column as strings
        """
        # Requests returns unicode encoding, return to ascii
        data = [line.split() for line in raw_data[1:]]
        # Transpose while keeping as list of lists
        data = list(map(list, zip(*data)))
        return data


Ogle = OgleClass()
