# -*- coding: utf-8 -*-

"""

    rhodecode.lib.compat

    ~~~~~~~~~~~~~~~~~~~~

    Python backward compatibility functions and common libs

    :created_on: Oct 7, 2011

    :author: marcink

    :copyright: (C) 2010-2010 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import os

import datetime

import functools

from rhodecode import __platform__, PLATFORM_WIN

#==============================================================================

# json

#==============================================================================

    DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S"

    DATE_FORMAT = "%Y-%m-%d"

    if isinstance(obj, complex):

        return [obj.real, obj.imag]

    elif isinstance(obj, datetime.datetime):

        return obj.strftime(DATETIME_FORMAT)

    elif isinstance(obj, datetime.date):

        return obj.strftime(DATE_FORMAT)

    elif isinstance(obj, set):

        return list(obj)

    elif isinstance(obj, OrderedDict):

        return obj.as_dict()

    else:

        raise NotImplementedError

try:

    import json

    # extended JSON encoder for json

    class ExtendedEncoder(json.JSONEncoder):

        def default(self, obj):

            try:

            except NotImplementedError:

                pass

            return json.JSONEncoder.default(self, obj)

    # monkey-patch JSON encoder to use extended version

    json.dumps = functools.partial(json.dumps, cls=ExtendedEncoder)

except ImportError:

    import simplejson as json

    def extended_encode(obj):

        try:

        except NotImplementedError:

            pass

        raise TypeError("%r is not JSON serializable" % (obj,))

    json.dumps = functools.partial(json.dumps, default=extended_encode)

#==============================================================================

# izip_longest

#==============================================================================

try:

    from itertools import izip_longest

except ImportError:

    import itertools

    def izip_longest(*args, **kwds):

        fillvalue = kwds.get("fillvalue")

        def sentinel(counter=([fillvalue] * (len(args) - 1)).pop):

            yield counter()  # yields the fillvalue, or raises IndexError

        fillers = itertools.repeat(fillvalue)

        iters = [itertools.chain(it, sentinel(), fillers)

                    for it in args]

        try:

            for tup in itertools.izip(*iters):

                yield tup

        except IndexError:

            pass

#==============================================================================

# OrderedDict

#==============================================================================

# Python Software Foundation License

# XXX: it feels like using the class with "is" and "is not" instead of "==" and

# "!=" should be faster.

class _Nil(object):

    def __repr__(self):

        return "nil"

    def __eq__(self, other):

        if (isinstance(other, _Nil)):

            return True

        else:

            return NotImplemented

    def __ne__(self, other):

        if (isinstance(other, _Nil)):

            return False

        else:

            return NotImplemented

_nil = _Nil()

class _odict(object):

    """Ordered dict data structure, with O(1) complexity for dict operations

    that modify one element.

    Overwriting values doesn't change their original sequential order.

    """

    def _dict_impl(self):

        return None

    def __init__(self, data=(), **kwds):

        """This doesn't accept keyword initialization as normal dicts to avoid

        a trap - inside a function or method the keyword args are accessible

        only as a dict, without a defined order, so their original order is

        lost.

        """

        if kwds:

            raise TypeError("__init__() of ordered dict takes no keyword "

                            "arguments to avoid an ordering trap.")

        self._dict_impl().__init__(self)

        # If you give a normal dict, then the order of elements is undefined

        if hasattr(data, "iteritems"):

            for key, val in data.iteritems():

                self[key] = val

        else:

            for key, val in data:

                self[key] = val

    # Double-linked list header

    def _get_lh(self):

        dict_impl = self._dict_impl()

        if not hasattr(self, '_lh'):

            dict_impl.__setattr__(self, '_lh', _nil)

        return dict_impl.__getattribute__(self, '_lh')

    def _set_lh(self, val):

        self._dict_impl().__setattr__(self, '_lh', val)

    name = Column("name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    lastname = Column("lastname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    _email = Column("email", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)

    ldap_dn = Column("ldap_dn", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    api_key = Column("api_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    user_log = relationship('UserLog', cascade='all')

    user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')

    repositories = relationship('Repository')

    user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')

    repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')

    repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')

    group_member = relationship('UsersGroupMember', cascade='all')

    notifications = relationship('UserNotification',)

    @hybrid_property

    def email(self):

        return self._email

    @email.setter

    def email(self, val):

        self._email = val.lower() if val else None

    @property

    def full_name(self):

        return '%s %s' % (self.name, self.lastname)

    @property

    def full_name_or_username(self):

        return ('%s %s' % (self.name, self.lastname)

                if (self.name and self.lastname) else self.username)

    @property

    def full_contact(self):

        return '%s %s <%s>' % (self.name, self.lastname, self.email)

    @property

    def short_contact(self):

        return '%s %s' % (self.name, self.lastname)

    @property

    def is_admin(self):

        return self.admin

    def __repr__(self):

        return "<%s('id:%s:%s')>" % (self.__class__.__name__,

                                     self.user_id, self.username)

    @classmethod

    def get_by_username(cls, username, case_insensitive=False, cache=False):

        if case_insensitive:

            q = cls.query().filter(cls.username.ilike(username))

        else:

            q = cls.query().filter(cls.username == username)

        if cache:

            q = q.options(FromCache(

                            "sql_cache_short",

                            "get_user_%s" % _hash_key(username)

                          )

            )

        return q.scalar()

    @classmethod

    def get_by_api_key(cls, api_key, cache=False):

        q = cls.query().filter(cls.api_key == api_key)

        if cache:

            q = q.options(FromCache("sql_cache_short",

                                    "get_api_key_%s" % api_key))

        return q.scalar()

    @classmethod

    def get_by_email(cls, email, case_insensitive=False, cache=False):

        if case_insensitive:

            q = cls.query().filter(cls.email.ilike(email))

        else:

            q = cls.query().filter(cls.email == email)

        if cache:

            q = q.options(FromCache("sql_cache_short",

                                    "get_api_key_%s" % email))

        return q.scalar()

    def update_lastlogin(self):

        """Update user lastlogin"""

        self.last_login = datetime.datetime.now()

        Session.add(self)

        log.debug('updated user %s lastlogin' % self.username)

    def __json__(self):

        return dict(

            email=self.email,

            full_name=self.full_name,

            full_name_or_username=self.full_name_or_username,

            short_contact=self.short_contact,

            full_contact=self.full_contact

        )

class UserLog(Base, BaseModel):

    __tablename__ = 'user_logs'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'},

    )

    user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)

    repository_name = Column("repository_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    user_ip = Column("user_ip", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    action = Column("action", UnicodeText(length=1200000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)

    @property

    def action_as_day(self):

        return datetime.date(*self.action_date.timetuple()[:3])

    user = relationship('User')

    repository = relationship('Repository', cascade='')

class UsersGroup(Base, BaseModel):

    __tablename__ = 'users_groups'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'},

    )

    users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_name = Column("users_group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)

    members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined")

    users_group_to_perm = relationship('UsersGroupToPerm', cascade='all')

    users_group_repo_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')

    def __repr__(self):

        return '<userGroup(%s)>' % (self.users_group_name)

    @classmethod

    def get_by_group_name(cls, group_name, cache=False,

                          case_insensitive=False):

        if case_insensitive:

            q = cls.query().filter(cls.users_group_name.ilike(group_name))

        else:

            q = cls.query().filter(cls.users_group_name == group_name)

        if cache:

            q = q.options(FromCache(

                            "sql_cache_short",

                            "get_user_%s" % _hash_key(group_name)

                          )

            )

        return q.scalar()

    @classmethod

    def get(cls, users_group_id, cache=False):

        users_group = cls.query()

        if cache:

            users_group = users_group.options(FromCache("sql_cache_short",

                                    "get_users_group_%s" % users_group_id))

        return users_group.get(users_group_id)

class UsersGroupMember(Base, BaseModel):

    __tablename__ = 'users_groups_members'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'},

    )

    users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    user = relationship('User', lazy='joined')

    users_group = relationship('UsersGroup')

    def __init__(self, gr_id='', u_id=''):

        self.users_group_id = gr_id

        self.user_id = u_id

class Repository(Base, BaseModel):

    __tablename__ = 'repositories'

    __table_args__ = (

        UniqueConstraint('repo_name'),

        {'extend_existing': True, 'mysql_engine':'InnoDB',