class Basin(object):
    """
    Class representing a given basin

    :param shortname: sfull basin's name
    :type shortname: str
    :param fullname: full basin's name
    :type fullname: str
    :param coordinates: list of coordinates for the basin in the order: min longitude, max longitude, min latitude,
     max latitude
    :type coordinates: tuple
    """

    def __init__(self, shortname, fullname, coordinates=None):
        self._shortname = shortname
        self._fullname = fullname
        if coordinates:
            self._coordinates = coordinates
        else:
            self._coordinates = [0, 0, 0, 0]

    def __eq__(self, other):
        if self.shortname != other.shortname or self.fullname != other.fullname:
            return False
        return True

    @property
    def shortname(self):
        """
        Basin's short name
        :rtype: str
        """
        return self._shortname

    @property
    def fullname(self):
        """
        Basin's full name
        :rtype: str
        """
        return self._fullname

    @property
    def min_lon(self):
        """
        Minimum longitude
        :rtype: int
        """
        return self._coordinates[0]

    @property
    def max_lon(self):
        """
        Maximum longitude
        :rtype: int
        """
        return self._coordinates[1]

    @property
    def min_lat(self):
        """
        Minimum latitude
        :rtype: int
        """
        return self._coordinates[2]

    @property
    def max_lat(self):
        """
        Maximum latitude
        :rtype: int
        """
        return self._coordinates[3]

    @property
    def lon(self):
        """
        Longitude limits of the basin
        :rtype: tuple
        """
        return self._coordinates[0:2]

    @property
    def lat(self):
        """
        Latitude limits of the basin
        :rtype: tuple
        """
        return self._coordinates[2:]


class Basins(object):
    """
    Predefined basins
    """
    Global = Basin('glob', 'Global_Ocean')
    """ Global ocean """

    Atlantic = Basin('Atl', 'Atlantic_Ocean')
    """ Atlantic ocean """
    NorthAtlantic = Basin('NAtl', 'North_Atlantic_Ocean')
    """ North Atlantic Ocean """
    TropicalAtlantic = Basin('TAtl', 'Tropical_Atlantic_Ocean')
    """ Tropical Atlantic Ocean """

    Pacific = Basin('Pac', 'Pacific_Ocean')
    """ Pacific Ocean """
    NorthPacific = Basin('NPac', 'North_Pacific_Ocean')
    """ North Pacific Ocean """
    TropicalPacific = Basin('TPac', 'Tropical_Pacific_Ocean')
    """ Tropical Pacific Ocean """
    IndoPacific = Basin('IndPac', 'Indo_Pacific_Ocean')
    """ Indo Pacific Ocean """

    Indian = Basin('Ind', 'Indian_Ocean')
    """ Indian Ocean """
    TropicalIndian = Basin('TInd', 'Tropical_Indian_Ocean')
    """ Tropical Indian Ocean """

    Antarctic = Basin('Anta', 'Antarctic_Ocean')
    """ Antarctic Ocean """
    AntarcticAtlantic = Basin('AntaAtl', 'Antarctic_Atlantic_Sector')
    """ Antarctic Ocean Atlantic Sector """
    AntarcticIndian = Basin('AntaInd', 'Antarctic_Indian_Sector')
    """ Antarctic Ocean Indian Sector"""

    Arctic = Basin('Arct', 'Arctic_Ocean')
    """ Arctic Ocean """
    ArcticNorthAtlantic = Basin('ArctNAtl', 'Arctic_Ocean_North_Atlantic')
    """ Arctic Ocean North Atlantic"""
    ArcticMarginalSeas = Basin('ArctMarg', 'Arctic_Marginal_Seas')
    """ Arctic Ocean """

    # ArctOcn

    Baffin = Basin('Baffin', 'Baffin')
    " Baffin "
    Baffin_Bay = Basin('BaffBay', 'Baffin_Bay')
    " Baffin_Bay "
    Baltic_Sea = Basin('Baltic', 'Baltic_Sea')
    " Baltic_Sea "
    BarKara = Basin('BarKara', 'BarKara')
    " BarKara "
    Barents_Sea = Basin('Barents', 'Barents_Sea')
    " Barents_Sea "
    Beaufort_Chukchi_Sea = Basin('BeaufortChukchi', 'Beaufort_Chukchi_Sea')
    " Beaufort_Chukchi_Sea "
    Beaufort_Sea = Basin('Beaufort', 'Beaufort_Sea')
    " Beaufort_Sea "
    Bellingshausen_Sea = Basin('Bellingshausen_', 'Bellingshausen_Sea')
    " Bellingshausen_Sea "
    Bering = Basin('Bering', 'Bering')
    " Bering "
    Bering_Strait = Basin('BeringStr', 'Bering_Strait')
    " Bering_Strait "
    CanArch = Basin('CanArch', 'CanArch')
    " CanArch "
    Canadian_Waters = Basin('Canadian', 'Canadian_Waters')
    " Canadian_Waters "
    Caspian_Sea = Basin('Caspian', 'Caspian_Sea')
    " Caspian_Sea "
    Central_Arctic = Basin('CArct', 'Central_Arctic')
    " Central_Arctic "
    Chukchi_Sea = Basin('Chukchi', 'Chukchi_Sea')
    " Chukchi_Sea "
    East_Siberian_Sea = Basin('ESiberian', 'East_Siberian_Sea')
    " East_Siberian_Sea "
    Eastern_Central_Arctic = Basin('ECArct', 'Eastern_Central_Arctic')
    " Eastern_Central_Arctic "
    Fram_Strait = Basin('Fram', 'Fram_Strait')
    " Fram_Strait "
    Global_Ocean = Basin('Global', 'Global_Ocean')
    " Global_Ocean "
    Greenland_Sea = Basin('Greenland', 'Greenland_Sea')
    " Greenland_Sea "
    Grnland = Basin('Grnland', 'Grnland')
    " Grnland "
    Hudson = Basin('Hudson', 'Hudson')
    " Hudson "
    Icelandic_Sea = Basin('Iceland', 'Icelandic_Sea')
    " Icelandic_Sea "
    Kara_Gate_Strait = Basin('KaraGate', 'Kara_Gate_Strait')
    " Kara_Gate_Strait "
    Kara_Sea = Basin('Kara', 'Kara')
    " Kara_Sea "
    Labrador_Sea = Basin('Labrador', 'Labrador')
    " Labrador_Sea "
    Laptev_East_Siberian_Chukchi_Seas = Basin('LaptevESiberianChukchi', 'Laptev_East_Siberian_Chukchi_Seas')
    " Laptev_East_Siberian_Chukchi_Seas "
    Laptev_East_Siberian_Seas = Basin('LaptevESiberian', 'Laptev_East_Siberian_Seas')
    " Laptev_East_Siberian_Seas "
    Laptev_Sea = Basin('Laptev', 'Laptev_Sea')
    " Laptev_Sea "
    Lincoln_Sea = Basin('Lincoln', 'Lincoln_Sea')
    " Lincoln_Sea "
    Mediterranean_Sea = Basin('Medit', 'Mediterranean_Sea')
    " Mediterranean_Sea "
    Nares_Strait = Basin('Nares', 'Nares_Strait')
    " Nares_Strait "
    Nordic_Barents_Seas = Basin('NordicBarents', 'Nordic_Barents_Seas')
    " Nordic_Barents_Seas "
    Nordic_Seas = Basin('Nordic', 'Nordic_Seas')
    " Nordic_Seas "
    NorthWest_Passage = Basin('NWPass', 'NorthWest_Passage')
    " NorthWest_Passage "
    North_Atlantic_Arctic = Basin('North_Atlantic_Arctic', 'North_Atlantic_Arctic')
    " North_Atlantic_Arctic "
    North_Hemisphere_Ocean = Basin('NHem', 'North_Hemisphere_Ocean')
    " North_Hemisphere_Ocean "
    Norwegian_Sea = Basin('Norwe', 'Norwegian_Sea')
    " Norwegian_Sea "
    Okhotsk = Basin('Okhotsk', 'Okhotsk')
    " Okhotsk "
    OpenOcean = Basin('OpenOcean', 'OpenOcean')
    " OpenOcean "
    Ross_Sea = Basin('Ross', 'Ross_Sea')
    " Ross_Sea "
    Serreze_Arctic = Basin('SerArc', 'Serreze_Arctic')
    " Serreze_Arctic "
    Southern_Hemisphere = Basin('SHem', 'Southern_Hemisphere')
    " Southern_Hemisphere "
    StLawr = Basin('StLawr', 'StLawr')
    " StLawr "
    Subpolar_Gyre = Basin('Subpolar', 'Subpolar_Gyre')
    " Subpolar_Gyre "
    TotalArc = Basin('TotalArc', 'TotalArc')
    " TotalArc "
    Vilkitsky_Strait = Basin('Vilkitsky', 'Vilkitsky_Strait')
    " Vilkitsky_Strait "
    Weddell_Sea = Basin('Weddell', 'Weddell_Sea')
    " Weddell_Sea "
    Western_Central_Arctic = Basin('Western_Central_Arctic', 'Western_Central_Arctic')
    " Western_Central_Arctic "

    @classmethod
    def parse(cls, basin):
        """
        Return the basin matching the given name. If the parameter basin is a Basin instance, directly returns the same
        instance. This bahaviour is intended to facilitate the development of methods that can either accept a name
        or a Basin instance to characterize the basin.

        :param basin: basin name or basin instance
        :type basin: str | Basin
        :return: basin instance corresponding to the basin name
        :rtype: Basin
        """
        if isinstance(basin, Basin):
            return basin
        for name in cls.__dict__.keys():
            if name.startswith('_'):
                continue
            # noinspection PyCallByClass
            value = cls.__getattribute__(cls, name)
            if isinstance(value, Basin):
                if basin.lower() in [value.shortname.lower(), value.fullname.lower()]:
                    return value
        return None