# vim: fileencoding=utf-8
#
import os
import re
import glob
from collections import OrderedDict
from ..templates.format.contents_format import ContentsFormat
from .files import read_file, read_link, join_paths, FilesError
import hashlib
import operator


class PackageError(Exception):
    pass


DEFAULT, NOTEXIST, NOTCORRECT = range(3)


class PackageAtomError(Exception):
    def __init__(self, message='Package atom error', errno=DEFAULT):
        self.message = message
        self.errno = errno


class VersionError(Exception):
    pass


class Version:
    '''Временный класс для работы со значениями версий.'''
    def __init__(self, version_value=None):
        if version_value is None:
            self._version_string = '-1'
            self._version_value = [-1]
        elif isinstance(version_value, Version):
            self._version_string = version_value._version_string
            self._version_value = version_value._version_value
        else:
            value = self._get_version_value(version_value)
            if not value:
                raise VersionError(
                            "Can't initialize Version object using '{0}'"
                            " value with type {1}".format(version_value,
                                                          type(version_value)))
            if isinstance(version_value, str):
                self._version_string = version_value.strip('-')
            else:
                self._version_string = str(version_value)

            self._version_value = value

    def _get_version_value(self, version):
        if isinstance(version, Version):
            return version._version_value

        elif isinstance(version, int):
            version_value = [str(version)]

        elif isinstance(version, float):
            version_value = []
            version = str(version).split('.')
            for version_part in version:
                version_value.append(int(version_part.strip()))

        elif isinstance(version, str):
            version = version.strip('-')
            version_value = []

            if '-' in version:
                version = version.split('-')[0]
            if '_' in version:
                version = version.split('_')[0]

            for version_part in version.split('.'):
                if version_part.isdigit():
                    version_part = int(version_part)
                    version_value.append(version_part)
                else:
                    return False
        else:
            return False

        return version_value

    def _use_compare_operation(self, compare_operator, other_value):
        '''Перегрузка x < y.'''
        version_value = self._version_value[:]

        other_value_length = len(other_value)
        version_value_length = len(version_value)

        if other_value_length < version_value_length:
            for counter in range(version_value_length - other_value_length):
                other_value.append(0)
        elif version_value_length < other_value_length:
            for counter in range(other_value_length - version_value_length):
                version_value.append(0)

        for lvalue, rvalue in zip(version_value, other_value):
            if lvalue == rvalue:
                continue

            if compare_operator(lvalue, rvalue):
                return True
            else:
                return False
        else:
            if (compare_operator != operator.lt and
               compare_operator != operator.gt and
               compare_operator != operator.ne):
                return True
            else:
                return False

    def __lt__(self, other):
        '''Перегрузка x < y.'''
        other_value = self._get_version_value(other)
        if not other_value:
            raise VersionError(
                            "Unable to compare Version object with the '{0}'"
                            " value of '{1}' type".format(other, type(other)))

        return self._use_compare_operation(operator.lt, other_value)

    def __le__(self, other):
        '''Перегрузка x <= y.'''
        other_value = self._get_version_value(other)
        if not other_value:
            raise VersionError(
                            "Unable to compare Version object with the '{0}'"
                            " value of '{1}' type".format(other, type(other)))

        return self._use_compare_operation(operator.le, other_value)

    def __eq__(self, other):
        '''Перегрузка x == y.'''
        other_value = self._get_version_value(other)
        if not other_value:
            raise VersionError(
                            "Unable to compare Version object with the '{0}'"
                            " value of '{1}' type".format(other, type(other)))

        return self._use_compare_operation(operator.eq, other_value)

    def __ne__(self, other):
        '''Перегрузка x != y.'''
        other_value = self._get_version_value(other)
        if not other_value:
            raise VersionError(
                            "Unable to compare Version object with the '{0}'"
                            " value of '{1}' type".format(other, type(other)))

        return self._use_compare_operation(operator.ne, other_value)

    def __gt__(self, other):
        '''Перегрузка x > y.'''
        other_value = self._get_version_value(other)
        if not other_value:
            raise VersionError(
                            "Unable to compare Version object with the '{0}'"
                            " value of '{1}' type".format(other, type(other)))

        return self._use_compare_operation(operator.gt, other_value)

    def __ge__(self, other):
        '''Перегрузка x >= y.'''
        other_value = self._get_version_value(other)
        if not other_value:
            raise VersionError(
                            "Unable to compare Version object with the '{0}'"
                            " value of '{1}' type".format(other, type(other)))

        return self._use_compare_operation(operator.ge, other_value)

    def __hash__(self):
        return hash(self._version_string)

    def __repr__(self):
        return '<Version: {}>'.format(self._version_string)

    def __str__(self):
        return self._version_string

    def __bool__(self):
        if self._version_value == [-1]:
            return False
        else:
            return True


class PackageAtomName:
    def __init__(self, atom_dictionary):
        self._package_directory = atom_dictionary['pkg_path']
        self._version = atom_dictionary['version']

    @property
    def name(self):
        return os.path.basename(self._package_directory)

    @property
    def category(self):
        return os.path.basename(os.path.dirname(self._package_directory))

    @property
    def version(self):
        return self._version

    @property
    def use_flags(self):
        use_path = os.path.join(self._package_directory, 'USE')
        try:
            return read_file(use_path).strip('\n').split(' ')
        except FilesError:
            raise PackageAtomError("could not read use flags for 'package'"
                                   " parameter: {}".format(self.package_atom))

    @property
    def pkg_path(self):
        return self._package_directory

    @property
    def slot(self):
        slot_path = os.path.join(self._package_directory, 'SLOT')
        try:
            return read_file(slot_path).strip('\n')
        except FilesError:
            raise PackageAtomError("could not read slot value for"
                                   " 'package': {}".format(self.package_atom))

    def __eq__(self, other):
        if isinstance(other, PackageAtomName):
            return (self._package_directory ==
                    other._package_directory)
        else:
            return False

    def __ne__(self, other):
        if isinstance(other, PackageAtomName):
            return (self._package_directory !=
                    other._package_directory)
        else:
            return False

    def __bool__(self):
        return bool(self._package_directory)

    def __repr__(self):
        return '<PackageAtomName: {}/{}>'.format(self.category,
                                                 self.name)


class PackageAtomParser:
    atom_regex = re.compile(r'''(?P<category>[^\s/]*)/
                                (?P<name>\D[\w\d]*(\-\D[\w\d]*)*)
                                (?P<version>-\d[^\s:]*)?
                                (?P<slot>:[^\s\[]*)?\s*
                                (?P<use_flags>\[\S*(?:\s+\S*)*\])?''',
                            re.VERBOSE)

    def __init__(self, pkg_path='/var/db/pkg',
                 chroot_path='/'):
        self.chroot_path = chroot_path

        if chroot_path != '/':
            self.pkg_path = join_paths(chroot_path, pkg_path)
        else:
            self.pkg_path = pkg_path

        self.package_atom = ''
        self._atom_dictionary = {}

    def parse_package_parameter(self, package_atom):
        self.package_atom = package_atom
        self._atom_dictionary = {}

        parsing_result = self.atom_regex.search(package_atom)

        if (not parsing_result or parsing_result.string != package_atom or
           not parsing_result.groupdict()['category'] or
           not parsing_result.groupdict()['name']):
            raise PackageAtomError("'package' parameter value '{}' is not"
                                   " correct".format(package_atom),
                                   errno=NOTCORRECT)

        self._atom_dictionary['category'] = parsing_result.groupdict(
                                                                  )['category']

        self._atom_dictionary['name'] = parsing_result.groupdict()['name']

        if parsing_result.groupdict()['version']:
            version_value = parsing_result.groupdict()['version'].strip('-')

            self._atom_dictionary['version'] = Version(version_value)

        if (parsing_result.groupdict()['slot'] and
           parsing_result.groupdict()['slot'] != ':'):
            self._atom_dictionary['slot'] = parsing_result.groupdict(
                                                                  )['slot'][1:]

        if parsing_result.groupdict()['use_flags']:
            self._atom_dictionary['use_flags'] = []
            use_flags = parsing_result.groupdict()['use_flags'].strip().\
                rstrip(']').lstrip('[')

            for use_flag in use_flags.split():
                self._atom_dictionary['use_flags'].append(use_flag.strip())

        self._check_package_existance()

        atom_name_object = PackageAtomName(self._atom_dictionary)
        self._atom_dictionary.clear()
        return atom_name_object

    def _check_package_existance(self, package_atom=''):
        if package_atom:
            self.parse_package_parameter(package_atom)
            return True
        else:
            if 'version' in self._atom_dictionary:
                full_name = self._atom_dictionary['name'] + '-' +\
                    self._atom_dictionary['version']._version_string
            else:
                full_name = self._atom_dictionary['name']

            if 'version' not in self._atom_dictionary:
                glob_result = glob.glob(
                 r'{0}/{1}/{2}-[0-9]*/CONTENTS'.format(
                                             self.pkg_path,
                                             self._atom_dictionary['category'],
                                             full_name))
            else:
                glob_result = glob.glob(
                 r'{0}/{1}/{2}*/CONTENTS'.format(
                                             self.pkg_path,
                                             self._atom_dictionary['category'],
                                             full_name))

            if not glob_result:
                raise PackageAtomError("Package from 'package' parameter value"
                                       " '{}' does not exist".format(
                                                            self.package_atom),
                                       errno=NOTEXIST)

            if len(glob_result) == 1:
                pkg_path = os.path.dirname(next(iter(glob_result)))
                self._check_slot_value(pkg_path)
                self._check_use_flags_value(pkg_path)

                parsed_name = self._atom_dictionary['name']
                full_name = os.path.basename(pkg_path)
                self._atom_dictionary['version'] = Version(
                                                  full_name[len(parsed_name):])
                self._atom_dictionary['pkg_path'] = pkg_path
            else:
                packages = dict()
                for contents_path in glob_result:
                    pkg_path = os.path.dirname(contents_path)
                    try:
                        self._check_slot_value(pkg_path)
                        self._check_use_flags_value(pkg_path)
                        parsed_name = self._atom_dictionary['name']
                        full_name = os.path.basename(pkg_path)
                        packages[pkg_path] = Version(
                                                  full_name[len(parsed_name):])
                    except PackageAtomError:
                        continue

                if not packages:
                    raise PackageAtomError(
                                       "Package from 'package' parameter value"
                                       " '{}' does not exist".format(
                                                            self.package_atom),
                                       errno=NOTEXIST)

                if len(packages) == 1:
                    pkg_path = next(iter(packages.keys()))
                    self._atom_dictionary['pkg_path'] = pkg_path
                    self._atom_dictionary['version'] = packages[pkg_path]
                else:
                    # Берем старшую версию.
                    pkg_path = sorted(packages.keys(),
                                      key=lambda path: packages[path])[-1]
                    self._atom_dictionary['pkg_path'] = pkg_path
                    self._atom_dictionary['version'] = packages[pkg_path]

    def _check_slot_value(self, pkg_path):
        if 'slot' in self._atom_dictionary:
            slot = self._get_slot_value(pkg_path)

            if slot != self._atom_dictionary['slot']:
                raise PackageAtomError("Package from 'package' parameter value"
                                       " '{}' does not exist".format(
                                                            self.package_atom),
                                       errno=NOTEXIST)

    def _check_use_flags_value(self, pkg_path):
        if 'use_flags' in self._atom_dictionary:
            use_flags = self._get_use_flags_value(pkg_path)

            for use_flag in self._atom_dictionary['use_flags']:
                if use_flag not in use_flags:
                    raise PackageAtomError(
                                       "Package from 'package' parameter value"
                                       " '{}' does not exist".format(
                                                            self.package_atom),
                                       errno=NOTEXIST)

    def _get_slot_value(self, pkg_path):
        slot_path = os.path.join(pkg_path, 'SLOT')
        try:
            return read_file(slot_path).strip('\n')
        except FilesError:
            raise PackageAtomError("could not read slot value for"
                                   " 'package': {}".format(self.package_atom))

    def _get_use_flags_value(self, pkg_path):
        use_path = os.path.join(pkg_path, 'USE')
        try:
            return read_file(use_path).strip('\n').split(' ')
        except FilesError:
            raise PackageAtomError("could not read use flags for 'package'"
                                   " parameter: {}".format(self.package_atom))

    def _get_category_packages(self, category):
        for path in glob.glob('{0}/{1}/*/CONTENTS'.format(self.pkg_path,
                                                          category)):
            yield path

    def get_file_package(self, file_path, with_slot=False, with_uses=False):
        if self.chroot_path != '/' and file_path.startswith(self.chroot_path):
            file_path = file_path[len(self.chroot_path):]

        for category in os.listdir(self.pkg_path):
            for contents_path in self._get_category_packages(category):
                try:
                    with open(contents_path, 'r') as contents_file:
                        for file_line in contents_file.readlines():
                            contents_name = file_line.split(' ')[1].strip()
                            if contents_name == file_path:
                                package = '/'.join(os.path.dirname(
                                                contents_path).split('/')[-2:])
                                return package
                except (OSError, IOError):
                    continue
        else:
            raise PackageAtomError("The file does not belong to any package")

    @property
    def atom_dictionary(self):
        return self._atom_dictionary

    @property
    def atom_name(self):
        return PackageAtomName(self._atom_dictionary)

    @atom_dictionary.setter
    def set_atom_dictionary(self, atom_dictionary):
        self._atom_dictionary = atom_dictionary

    @property
    def category(self):
        if 'category' in self._atom_dictionary:
            return self._atom_dictionary['category']
        else:
            return False

    @property
    def name(self):
        if 'name' in self._atom_dictionary:
            return self._atom_dictionary['name']
        else:
            return False

    @property
    def slot(self):
        if 'slot' in self._atom_dictionary:
            return self._atom_dictionary['slot']
        else:
            if 'contents' in self._atom_dictionary:
                return self._get_slot_value(self._atom_dictionary['contents'])
            return False

    @property
    def use_flags(self):
        if 'use_flags' in self._atom_dictionary:
            return self._atom_dictionary['use_flags']
        else:
            if 'contents' in self._atom_dictionary:
                return self._get_use_flags_value(
                                             self._atom_dictionary['contents'])
            else:
                return False


class Package:
    re_cfg = re.compile(r'/\._cfg\d{4}_')

    def __init__(self, package_atom, pkg_path='/var/db/pkg', chroot_path='/'):
        self.chroot_path = chroot_path

        self.contents_file_path = self._get_contents_path(package_atom)
        if (chroot_path != '/' and
           not self.contents_file_path.startswith(chroot_path)):
            self.contents_file_path = join_paths(chroot_path,
                                                 self.contents_file_path)

        if not os.path.exists(self.contents_file_path):
            raise PackageError("Can not find CONTENTS file in path: {}".format(
                                                        self.contents_file_path
                                                                             ))
        self.contents_dictionary = OrderedDict()
        self.read_contents_file()

    def _get_contents_path(self, package_atom):
        if isinstance(package_atom, str):
            package_atom_parser = PackageAtomParser(
                                                  chroot_path=self.chroot_path)
            atom_name = package_atom_parser.parse_package_parameter(
                                                                  package_atom)
            return os.path.join(atom_name.pkg_path,
                                'CONTENTS')
        if isinstance(package_atom, PackageAtomName):
            return os.path.join(package_atom.pkg_path,
                                'CONTENTS')
        else:
            raise PackageError(
                            "Incorrect 'pakage_atom' value: '{}', type: '{}''".
                            format(package_atom, type(package_atom)))

    def remove_cfg_prefix(self, file_name):
        return self.re_cfg.sub('/', file_name)

    def remove_chroot_path(self, file_name):
        if self.chroot_path != '/' and file_name.startswith(self.chroot_path):
            return file_name[len(self.chroot_path):]
        else:
            return file_name

    def read_contents_file(self):
        try:
            contents_text = read_file(self.contents_file_path)
        except FilesError as error:
            raise PackageError(str(error))
        if contents_text:
            contents_format = ContentsFormat(contents_text,
                                             template_parser=False)
            self.contents_dictionary = contents_format._document_dictionary
            return True
        else:
            return False

    def write_contents_file(self):
        pass

    def render_contents_file(self):
        contents_format = ContentsFormat('', template_parser=False)
        contents_format._document_dictionary = self.contents_dictionary
        return contents_format.get_document_text()

    def add_dir(self, file_name):
        file_name = self.remove_cfg_prefix(file_name)
        file_name = self.remove_chroot_path(file_name)

        if (file_name != '/' and
            (file_name not in self.contents_dictionary
             or self.contents_dictionary[file_name]['type'] != 'dir')):
                self.add_dir(os.path.dirname(file_name))
                contents_item = OrderedDict({'type': 'dir'})
                self.contents_dictionary[file_name] = contents_item

    def add_sym(self, file_name):
        file_name = self.remove_cfg_prefix(file_name)

        real_path = file_name
        file_name = self.remove_chroot_path(file_name)

        if real_path == file_name:
            real_path = join_paths(self.chroot_path, file_name)

        self.add_dir(os.path.dirname(file_name))
        mtime = str(int(os.lstat(real_path).st_mtime))
        try:
            contents_item = OrderedDict({'type': 'sym',
                                         'target': read_link(real_path),
                                         'mtime': mtime})
        except FilesError as error:
            raise PackageError(str(error))

        self.contents_dictionary[file_name] = contents_item

    def add_obj(self, file_name):
        file_name = self.remove_cfg_prefix(file_name)

        real_path = file_name
        file_name = self.remove_chroot_path(file_name)

        if real_path == file_name:
            real_path = join_paths(self.chroot_path, file_name)
        self.add_dir(os.path.dirname(file_name))

        try:
            file_text = read_file(real_path).encode()
        except FilesError as error:
            raise PackageError(str(error))

        contents_item = OrderedDict({'type': 'obj',
                                     'md5': hashlib.md5(file_text).hexdigest(),
                                     'mtime':
                                     str(int(os.lstat(real_path).st_mtime))})
        self.contents_dictionary[file_name] = contents_item

    def add_file(self, file_name):
        if file_name != '/':
            real_path = file_name
            file_name = self.remove_chroot_path(file_name)

            if real_path != file_name:
                real_path = join_paths(self.chroot_path, file_name)
            if os.path.isdir(real_path):
                self.add_dir(file_name)
            elif os.path.islink(real_path):
                self.add_link(file_name)
            elif os.path.isfile(real_path):
                self.add_obj(file_name)

    def modify_contents_item(self, file_name, item_value):
        pass

    def remove_file(self, file_name):
        pass

    def remove_empty_directories(self):
        pass

    def check_file_md5(self, file_path):
        pass