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

"""

    rhodecode.lib.compat

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

    Python backward compatibility functions and common libs

    :created_on: Oct 7, 2011

    :author: marcink

    :copyright: (C) 2009-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/>.

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

# json

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

try:

    import json

except ImportError:

    import simplejson as json

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

# izip_longest

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

try:

    from itertools import izip_longest

except ImportError:

    import itertools

    def izip_longest(*args, **kwds): # noqa

        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):

            val = self[k]

            del self[k]

            return val

        except KeyError:

            if x == _nil:

                raise

            return x

    def popitem(self):

        try:

            dict_impl = self._dict_impl()

            key = dict_impl.__getattribute__(self, 'lt')

            return key, self.pop(key)

        except KeyError:

            raise KeyError("'popitem(): ordered dictionary is empty'")

    def riterkeys(self):

        """To iterate on keys in reversed order.

        """

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lt')

        while curr_key != _nil:

            yield curr_key

            curr_key = dict_impl.__getitem__(self, curr_key)[0]

    __reversed__ = riterkeys

    def rkeys(self):

        """List of the keys in reversed order.

        """

        return list(self.riterkeys())

    def ritervalues(self):

        """To iterate on values in reversed order.

        """

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lt')

        while curr_key != _nil:

            curr_key, val, _ = dict_impl.__getitem__(self, curr_key)

            yield val

    def rvalues(self):

        """List of the values in reversed order.

        """

        return list(self.ritervalues())

    def riteritems(self):

        """To iterate on (key, value) in reversed order.

        """

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lt')

        while curr_key != _nil:

            pred_key, val, _ = dict_impl.__getitem__(self, curr_key)

            yield curr_key, val

            curr_key = pred_key

    def ritems(self):

        """List of the (key, value) in reversed order.

        """

        return list(self.riteritems())

    def firstkey(self):

        if self:

            return self._dict_impl().__getattribute__(self, 'lh')

        else:

            raise KeyError("'firstkey(): ordered dictionary is empty'")

    def lastkey(self):

        if self:

            return self._dict_impl().__getattribute__(self, 'lt')

        else:

            raise KeyError("'lastkey(): ordered dictionary is empty'")

    def as_dict(self):

        return self._dict_impl()(self.items())

    def _repr(self):

        """_repr(): low level repr of the whole data contained in the odict.

        Useful for debugging.

        """

        dict_impl = self._dict_impl()

        form = "odict low level repr lh,lt,data: %r, %r, %s"

        return form % (dict_impl.__getattribute__(self, 'lh'),

                       dict_impl.__getattribute__(self, 'lt'),

                       dict_impl.__repr__(self))

class OrderedDict(_odict, dict):

    def _dict_impl(self):

        return dict

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

# OrderedSet

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

from sqlalchemy.util import OrderedSet

import os

import sys

import time

import errno

from warnings import warn

from multiprocessing.util import Finalize

class LockHeld(Exception):

    pass

class DaemonLock(object):

    """daemon locking

    USAGE:

    try:

        l = DaemonLock(file_='/path/tolockfile',desc='test lock')

        main()

        l.release()

    except LockHeld:

        sys.exit(1)

    """

    def __init__(self, file_=None, callbackfn=None,

                 desc='daemon lock', debug=False):

        self.pidfile = file_ if file_ else os.path.join(

                                                    os.path.dirname(__file__),

                                                    'running.lock')

        self.callbackfn = callbackfn

        self.desc = desc

        self.debug = debug

        self.held = False

        #run the lock automatically !

        self.lock()

        self._finalize = Finalize(self, DaemonLock._on_finalize,

                                    args=(self, debug), exitpriority=10)

    @staticmethod

    def _on_finalize(lock, debug):

        if lock.held:

            if debug:

                print 'leck held finilazing and running lock.release()'

            lock.release()

    def lock(self):

        """

        locking function, if lock is present it

        will raise LockHeld exception

        """

        lockname = '%s' % (os.getpid())

        if self.debug:

            print 'running lock'

        self.trylock()

        self.makelock(lockname, self.pidfile)

        return True

    def trylock(self):

        running_pid = False

        if self.debug:

            print 'checking for already running process'

        try:

            pidfile = open(self.pidfile, "r")

            pidfile.seek(0)

            running_pid = int(pidfile.readline())

            pidfile.close()

            if self.debug:

                print ('lock file present running_pid: %s, '

                       'checking for execution') % running_pid

            # Now we check the PID from lock file matches to the current

            # process PID

            if running_pid:

                try:

                    kill(running_pid, 0)

                except OSError, exc:

                    if exc.errno in (errno.ESRCH, errno.EPERM):

                        print ("Lock File is there but"

                               " the program is not running")

                        print "Removing lock file for the: %s" % running_pid

                        self.release()

                    else:

                        raise

                else:

                    print "You already have an instance of the program running"

                    print "It is running as process %s" % running_pid

                    raise LockHeld()

        except IOError, e:

            if e.errno != 2:

                raise

    def release(self):

        """releases the pid by removing the pidfile

        """

        if self.debug:

            print 'trying to release the pidlock'

        if self.callbackfn:

            #execute callback function on release

            if self.debug:

                print 'executing callback function %s' % self.callbackfn