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

"""

    vcs.nodes

    ~~~~~~~~~

    Module holding everything related to vcs nodes.

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

import os

import stat

import posixpath

import mimetypes

from rhodecode.lib.vcs.backends.base import EmptyChangeset

from rhodecode.lib.vcs.exceptions import NodeError, RemovedFileNodeError

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.utils import safe_unicode

class NodeKind:

    SUBMODULE = -1

    DIR = 1

    FILE = 2

class NodeState:

    ADDED = u'added'

    CHANGED = u'changed'

    NOT_CHANGED = u'not changed'

    REMOVED = u'removed'

class NodeGeneratorBase(object):

    """

    Base class for removed added and changed filenodes, it's a lazy generator

    class that will create filenodes only on iteration or call

    The len method doesn't need to create filenodes at all

    """

    def __init__(self, current_paths, cs):

        self.cs = cs

        self.current_paths = current_paths

    def __call__(self):

        return [n for n in self]

    def __getslice__(self, i, j):

        for p in self.current_paths[i:j]:

            yield self.cs.get_node(p)

    def __len__(self):

        return len(self.current_paths)

    def __iter__(self):

        for p in self.current_paths:

            yield self.cs.get_node(p)

class AddedFileNodesGenerator(NodeGeneratorBase):

    """

    Class holding Added files for current changeset

    """

    pass

class ChangedFileNodesGenerator(NodeGeneratorBase):

    """

    Class holding Changed files for current changeset

    """

    pass

class RemovedFileNodesGenerator(NodeGeneratorBase):

    """

    Class holding removed files for current changeset

    """

    def __iter__(self):

        for p in self.current_paths:

            yield RemovedFileNode(path=p)

    def __getslice__(self, i, j):

        for p in self.current_paths[i:j]:

            yield RemovedFileNode(path=p)

class Node(object):

    """

    Simplest class representing file or directory on repository.  SCM backends

    should use ``FileNode`` and ``DirNode`` subclasses rather than ``Node``

    directly.

    Node's ``path`` cannot start with slash as we operate on *relative* paths

    only. Moreover, every single node is identified by the ``path`` attribute,

    so it cannot end with slash, too. Otherwise, path could lead to mistakes.

    """

    def __init__(self, path, kind):

        if path.startswith('/'):

            raise NodeError("Cannot initialize Node objects with slash at "

                "the beginning as only relative paths are supported")

        self.path = path.rstrip('/')

        if path == '' and kind != NodeKind.DIR:

            raise NodeError("Only DirNode and its subclasses may be "

                            "initialized with empty path")

        self.kind = kind

        #self.dirs, self.files = [], []

        if self.is_root() and not self.is_dir():

            raise NodeError("Root node cannot be FILE kind")

    def mode(self):

        """

        Returns lazily mode of the FileNode. If ``changeset`` is not set, would

        use value given at initialization or 0100644 (default).

        """

        if self.changeset:

            mode = self.changeset.get_file_mode(self.path)

        else:

            mode = self._mode

        return mode

    def _get_content(self):

        if self.changeset:

            content = self.changeset.get_file_content(self.path)

        else:

            content = self._content

        return content

    @property

    def content(self):

        """

        Returns lazily content of the FileNode. If possible, would try to

        decode content from UTF-8.

        """

        content = self._get_content()

        if bool(content and '\0' in content):

            return content

        return safe_unicode(content)

    @LazyProperty

    def size(self):

        if self.changeset:

            return self.changeset.get_file_size(self.path)

        raise NodeError("Cannot retrieve size of the file without related "

            "changeset attribute")

    @LazyProperty

    def message(self):

        if self.changeset:

            return self.last_changeset.message

        raise NodeError("Cannot retrieve message of the file without related "

            "changeset attribute")

    @LazyProperty

    def last_changeset(self):

        if self.changeset:

            return self.changeset.get_file_changeset(self.path)

        raise NodeError("Cannot retrieve last changeset of the file without "

            "related changeset attribute")

    def get_mimetype(self):

        """

        Mimetype is calculated based on the file's content. If ``_mimetype``

        attribute is available, it will be returned (backends which store

        mimetypes or can easily recognize them, should set this private

        attribute to indicate that type should *NOT* be calculated).

        """

        if hasattr(self, '_mimetype'):

            if (isinstance(self._mimetype, (tuple, list,)) and

                len(self._mimetype) == 2):

                return self._mimetype

            else:

                raise NodeError('given _mimetype attribute must be an 2 '

                               'element list or tuple')

        mtype, encoding = mimetypes.guess_type(self.name)

        if mtype is None:

            if self.is_binary:

                mtype = 'application/octet-stream'

                encoding = None

            else:

                mtype = 'text/plain'

                encoding = None

        return mtype, encoding

    @LazyProperty

    def mimetype(self):

        """

        Wrapper around full mimetype info. It returns only type of fetched

        mimetype without the encoding part. use get_mimetype function to fetch

        full set of (type,encoding)

        """

        return self.get_mimetype()[0]

    @LazyProperty

    def mimetype_main(self):

        return self.mimetype.split('/')[0]

    @LazyProperty

    def lexer(self):

        """

        Returns pygment's lexer class. Would try to guess lexer taking file's

        content, name and mimetype.

        """

        try:

            lexer = lexers.guess_lexer_for_filename(self.name, self.content, stripnl=False)

        except lexers.ClassNotFound:

            lexer = lexers.TextLexer(stripnl=False)

        # returns first alias

        return lexer

    @LazyProperty

    def lexer_alias(self):

        """

        Returns first alias of the lexer guessed for this file.

        """

        return self.lexer.aliases[0]

    @LazyProperty

    def history(self):

        """

        Returns a list of changeset for this file in which the file was changed

        """

        if self.changeset is None:

            raise NodeError('Unable to get changeset for this FileNode')

        return self.changeset.get_file_history(self.path)

    @LazyProperty

    def annotate(self):

        """

        Returns a list of three element tuples with lineno,changeset and line

        """

        if self.changeset is None:

            raise NodeError('Unable to get changeset for this FileNode')

        return self.changeset.get_file_annotate(self.path)

    @LazyProperty

    def state(self):

        if not self.changeset:

            raise NodeError("Cannot check state of the node if it's not "

                "linked with changeset")

        elif self.path in (node.path for node in self.changeset.added):

            return NodeState.ADDED

        elif self.path in (node.path for node in self.changeset.changed):

            return NodeState.CHANGED

        else:

            return NodeState.NOT_CHANGED

    @property

    def is_binary(self):

        """

        Returns True if file has binary content.

        """

        _bin = '\0' in self._get_content()

        return _bin

    @LazyProperty

    def extension(self):

        """Returns filenode extension"""

        return self.name.split('.')[-1]

    @property

    def is_executable(self):

        """

        Returns ``True`` if file has executable flag turned on.

        """

        return bool(self.mode & stat.S_IXUSR)

    def __repr__(self):

        return '<%s %r @ %s>' % (self.__class__.__name__, self.path,

                                 getattr(self.changeset, 'short_id', ''))

class RemovedFileNode(FileNode):

    """

    Dummy FileNode class - trying to access any public attribute except path,

    name, kind or state (or methods/attributes checking those two) would raise

    RemovedFileNodeError.

    """

    ALLOWED_ATTRIBUTES = [

        'name', 'path', 'state', 'is_root', 'is_file', 'is_dir', 'kind',

        'added', 'changed', 'not_changed', 'removed'

    ]

    def __init__(self, path):

        """

        :param path: relative path to the node

        """

        super(RemovedFileNode, self).__init__(path=path)

    def __getattribute__(self, attr):

        if attr.startswith('_') or attr in RemovedFileNode.ALLOWED_ATTRIBUTES:

            return super(RemovedFileNode, self).__getattribute__(attr)

        raise RemovedFileNodeError("Cannot access attribute %s on "

            "RemovedFileNode" % attr)

    @LazyProperty

    def state(self):

        return NodeState.REMOVED