from __future__ import division

"""Proxy class to DAP data.

This module implements a proxy object that behaves like an array and 
downloads data transparently from a DAP server when sliced. It is used
when building a representation of the dataset, and should be not 
directly used.
"""

__author__ = "Roberto De Almeida <rob@pydap.org>"

import sys

from dap.xdr import DapUnpacker
from dap.helper import fix_slice
from dap.util.http import openurl

try:
    from numpy import ndarray as ndarray_
except ImportError:
    ndarray_ = None


class Proxy(object):
    """
    A proxy to data stored in a DODS server.
    """
    def __init__(self, url, id, shape, type, filters=None, cache=None, username=None, password=None):
        self.url = url
        self.id = id
        self.shape = shape
        self.type = type

        self.filters = filters or []

        self.cache = cache
        self.username = username
        self.password = password

    def __iter__(self):
        return iter(self[:])

    def __getitem__(self, index):
        """
        Download data from DAP server.
        
        When the proxy object is sliced, it build an URL from the slice
        and retrieves the data from the DAP server.
        """
        # Build the base URL.
        url = '%s.dods?%s' % (self.url, self.id)

        if self.shape:
            # Fix the index for incomplete slices or ellipsis.
            index = fix_slice(len(self.shape), index)

            # Force index to tuple, to iterate over the slices.
            if not isinstance(index, tuple):
                index = index,

            # Iterate over the sliced dimensions.
            i = 0
            outshape = []
            for dimension in index:
                # If dimension is a slice, get start, step and stop.
                if isinstance(dimension, slice):
                    start = dimension.start  or 0
                    step  = dimension.step   or 1
                    if dimension.stop:
                        stop = dimension.stop-1
                    else:
                        stop = self.shape[i]-1

                # Otherwise, retrieve a single value.
                else:
                    start = dimension
                    stop  = dimension
                    step  = 1

                # When stop is not specified, use the shape.
                if stop == sys.maxint or stop > self.shape[i]-1:
                    stop = self.shape[i]-1
                # Negative slices. 
                elif stop < 0:
                    stop = self.shape[i]+stop

                # Negative starting slices.
                if start < 0: start = self.shape[i]+start

                # Build the URL used to retrieve the data.
                url = '%s[%s:%s:%s]' % (url, str(start), str(step), str(stop))

                # outshape is a list of the slice dimensions.
                outshape.append(1+(stop-start)//step)
                
                # Update to next dimension.
                i += 1

        else:
            # No need to resize the data.
            outshape = None

        # Make the outshape consistent with the numpy and pytables conventions.
        if outshape is not None:
            outshape = self._reduce_outshape(outshape)

        # Check for filters.
        if self.filters:
            ce = '&'.join(self.filters)
            url = '%s&%s' % (url, ce)

        # Fetch data.
        resp, data = openurl(url, self.cache, self.username, self.password)

        # First lines are ASCII information that end with 'Data:\n'.
        start = data.index('Data:\n') + len('Data:\n')
        xdrdata = data[start:]

        # Unpack data.
        output = DapUnpacker(xdrdata, self.shape, self.type, outshape).getvalue()

        # Convert length 1 arrays to scalars
        if ndarray_:
            if outshape == () and isinstance(output, ndarray_):
                output = output[0]

        return output


    def _reduce_outshape(self, outshape):
        """Make the outshape consistent with the numpy and pytables conventions.

        (1, N) -> (N,)
        (N, 1) -> (N,)
        (N, M, 1) -> (N, M)

        Basically, all ones are removed from the shape.
        """
        return tuple([index for index in outshape if index != 1])

def _test():
    import doctest
    doctest.testmod()

if __name__ == "__main__":
    _test()