# 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):
    '''Исключение выбрасываемое при ошибках в объектах Package, работающих
    с CONTENTS-файлами пакетов.'''
    pass


# Коды ошибок ATOM-парсера.
DEFAULT, NOTEXIST, NOTCORRECT = range(3)


class PackageAtomError(Exception):
    '''Исключение выбрасываемое при ошибках разбора ATOM-названий.'''
    def __init__(self, message='Package atom error', errno=DEFAULT,
                 atom_name=None):
        self.message = message
        self.errno = errno
        self.atom = atom_name


class VersionError(Exception):
    '''Исключение выбрасываемое объектами Version.'''
    pass


class PackageNotFound(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):
        '''Вспомогательный метод для реализации различных операций сравнения.
        '''
        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:
    '''Класс для хранения результата определения пакета. Для определения пакета
    использует путь к его pkg директории.'''
    def __init__(self, atom_dictionary, parser=None):
        self._package_directory = atom_dictionary['pkg_path']
        self._version = atom_dictionary['version']
        if self._package_directory is None:
            self._name = 'None'
        else:
            self._name = atom_dictionary.get('name',
                                             os.path.basename(
                                                      self._package_directory))
        self._parser = parser

    @property
    def name(self):
        if self._package_directory is None:
            return 'None'
        return self._name

    @property
    def fullname(self):
        if self._package_directory is None:
            return 'None'
        return os.path.basename(self._package_directory)

    @property
    def category(self):
        if self._package_directory is None:
            return 'None'
        return os.path.basename(os.path.dirname(self._package_directory))

    @property
    def atom(self):
        if self._package_directory is None:
            return 'None'
        return "{}/{}".format(self.category, self.fullname)

    @property
    def version(self):
        if self._package_directory is None:
            return 'None'
        return self._version

    @property
    def use_flags(self):
        if self._package_directory is None:
            return []
        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),
                                   atom_name=self.package_atom)

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

    @property
    def slot(self):
        if self._package_directory is None:
            return None
        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),
                                   atom_name=self.package_atom)

    def __eq__(self, other):
        print('EQ')
        print('other:', other)
        if isinstance(other, PackageAtomName):
            result = (self._package_directory ==
                      other._package_directory)
            print('result:', result)
            return result
        elif isinstance(other, str) and self._parser:
            try:
                other_atom = self._parser.parse_package_parameter(other)
                print('OTHER ATOM:', other_atom)
                result = (self._package_directory ==
                          other_atom._package_directory)
                print('result:', result)
                return result
            except Exception:
                return False
        else:
            return False

    def __ne__(self, other):
        if isinstance(other, PackageAtomName):
            return (self._package_directory !=
                    other._package_directory)
        elif isinstance(other, str) and self._parser:
            try:
                other_atom = self._parser.parse_package_parameter(other)
                return self._package_directory != other_atom._package_directory
            except Exception:
                return True
        else:
            return False

    def __bool__(self):
        if self._package_directory is None:
            return True
        return bool(self._package_directory)

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

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


NonePackage = PackageAtomName({'pkg_path': None, 'version': None})


class PackageAtomParser:
    '''Класс для парсинга параметра package, его проверки, а также определения
    принадлежности файла пакету.'''
    package_name_pattern =\
        r'(?P<name>\D[\w\d]*(\-\D[\w\d]*)*)(?P<version>-\d[^\s:]*)?'

    atom_regex = re.compile(r'''(?P<category>[^\s/]*)/
                                {0}
                                (?P<slot>:[^\s\[]*)?\s*
                                (?P<use_flags>\[\S*(?:\s+\S*)*\])?'''.format(
                                                           package_name_pattern
                                                                            ),
                            re.VERBOSE)
    package_name_regex = re.compile(package_name_pattern)

    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):
        '''Метод для разбора значения package, после разбора инициирует
        проверку полученных значений. Возвращает объект PackageAtomName.'''
        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, atom_name=self.atom_name)

        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, parser=self)
        self._atom_dictionary.clear()
        return atom_name_object

    def _check_package_existance(self, package_atom=''):
        '''Метод для проверки существования пакета. Существование пакета
        определяется наличием соответствующего CONTENTS файла.'''
        if package_atom:
            self.parse_package_parameter(package_atom)
            return True
        else:
            # Используем glob-паттерн для поиска.
            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,
                                       atom_name=self.package_atom)

            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()
                # Если подходящих пакетов много -- проверяем по use-флагам,
                # слотам и версии, если таковые заданы.
                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,
                                       atom_name=self.package_atom)

                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):
        '''Метод для проверки полученного из параметра package значения slot.
        '''
        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,
                                       atom_name=self.package_atom)

    def _check_use_flags_value(self, pkg_path):
        '''Метод для проверки полученных из параметра package значений
        use-флагов.'''
        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,
                                       atom_name=self.package_atom)

    def _get_slot_value(self, pkg_path):
        '''Метод для получения значения slot из файла SLOT.'''
        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),
                                   atom_name=self.package_atom)

    def _get_use_flags_value(self, pkg_path):
        '''Метод для получения списка значений use-флагов из файла USE.'''
        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),
                                   atom_name=self.package_atom)

    def _get_category_packages(self, category):
        '''Генератор имен категорий, имеющихся в /var/db/pkg'''
        for path in glob.glob('{0}/{1}/*/CONTENTS'.format(self.pkg_path,
                                                          category)):
            yield path

    def get_file_package(self, file_path):
        '''Метод для определения пакета, которому принадлежит файл.'''
        # Удаляем часть пути соответствующую chroot_path
        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_path = os.path.dirname(contents_path)

                                package_name = os.path.basename(package_path)
                                parsing_result = self.package_name_regex.\
                                    search(package_name)
                                version = parsing_result.groupdict()['version']
                                version = Version(version)

                                package_atom = PackageAtomName(
                                                     {'pkg_path': package_path,
                                                      'version': version},
                                                     parser=self)
                                return package_atom
                except (OSError, IOError):
                    continue
        else:
            raise PackageNotFound("The file does not belong to any package")

    @property
    def atom_dictionary(self):
        '''Метод для получения ATOM-словаря.'''
        return self._atom_dictionary

    @property
    def atom_name(self):
        '''Метод для получения из ATOM-словаря объекта PackageAtomName.'''
        return PackageAtomName(self._atom_dictionary, parser=self)

    @atom_dictionary.setter
    def set_atom_dictionary(self, atom_dictionary):
        '''Метод для установки ATOM-словаря.'''
        self._atom_dictionary = atom_dictionary

    @property
    def category(self):
        '''Метод для получения категории пакета из ATOM-словаря.'''
        if 'category' in self._atom_dictionary:
            return self._atom_dictionary['category']
        else:
            return False

    @property
    def name(self):
        '''Метод для получения имени пакета из ATOM-словаря.'''
        if 'name' in self._atom_dictionary:
            return self._atom_dictionary['name']
        else:
            return False

    @property
    def slot(self):
        '''Метод для получения значения slot из ATOM-словаря.'''
        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):
        '''Метод для получения use-флагов из ATOM-словаря.'''
        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)
        self.package_name = 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):
        '''Метод для получения из ATOM-названия или готового объекта
        PackageAtomName пути к файлу CONTENTS.'''
        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')
        elif isinstance(package_atom, PackageAtomName):
            return os.path.join(package_atom.pkg_path,
                                'CONTENTS')
        else:
            raise PackageError(
                           "Incorrect 'package_atom' value: '{}', type: '{}''".
                           format(package_atom, type(package_atom)))

    def remove_cfg_prefix(self, file_name):
        '''Метод для удаления префикса ._cfg????_.'''
        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):
        '''Метод для чтения файла CONTENTS.'''
        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,
                                             None,
                                             template_parser=False)
            self.contents_dictionary = contents_format._document_dictionary
            return True
        else:
            return False

    def write_contents_file(self):
        '''Метод для записи файла CONTENTS.'''
        contents_file = open(self.contents_file_path, 'w')
        contents_text = self.render_contents_file()
        contents_file.write(contents_text)
        contents_file.close()

    def render_contents_file(self):
        '''Метод для получения текста файла CONTENTS.'''
        contents_format = ContentsFormat('', None, template_parser=False)
        contents_format._document_dictionary = self.contents_dictionary
        return contents_format.document_text

    def add_dir(self, file_name):
        '''Метод для добавления в CONTENTS директорий.'''
        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, target_path=None):
        '''Метод для добавления в CONTENTS символьных ссылок.'''
        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)

        if target_path is None:
            target = read_link(real_path)
        else:
            target = target_path

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

        self.contents_dictionary[file_name] = contents_item

    def add_obj(self, file_name, file_md5=None):
        '''Метод для добавления в CONTENTS обычных файлов как obj.'''
        real_path = file_name
        file_name = self.remove_chroot_path(file_name)
        file_name = self.remove_cfg_prefix(file_name)

        if real_path == file_name:
            real_path = join_paths(self.chroot_path, file_name)
        self.add_dir(os.path.dirname(file_name))
        if file_md5 is not None:
            md5_value = file_md5
        else:
            try:
                file_text = read_file(real_path).encode()
            except FilesError as error:
                raise PackageError(str(error))
            md5_value = hashlib.md5(file_text).hexdigest()

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

    def add_file(self, file_name):
        '''Метод для добавления в CONTENTS файла любого типа.'''
        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 remove_obj(self, file_path):
        '''Метод для удаления файлов и ссылок.'''
        file_path = self.remove_chroot_path(file_path)
        file_path = self.remove_cfg_prefix(file_path)

        if file_path in self.contents_dictionary:
            self.contents_dictionary.pop(file_path)

    def remove_dir(self, file_path):
        '''Метод для удаления из CONTENTS файлов и директорий находящихся
        внутри удаляемой директории и самой директории.'''
        directory_path = self.remove_chroot_path(file_path)
        paths_to_remove = []

        for file_path in self.contents_dictionary:
            if file_path.startswith(directory_path):
                paths_to_remove.append(file_path)

        for file_path in paths_to_remove:
            self.contents_dictionary.pop(file_path)

    def clear_dir(self, file_path):
        '''Метод для удаления из CONTENTS файлов и директорий находящихся
        внутри очищаемой директории.'''
        directory_path = self.remove_chroot_path(file_path)
        paths_to_remove = []

        for file_path in self.contents_dictionary:
            if file_path == directory_path:
                continue
            if file_path.startswith(directory_path):
                paths_to_remove.append(file_path)

        for file_path in paths_to_remove:
            self.contents_dictionary.pop(file_path)

    def remove_empty_directories(self):
        '''Метод для удаления из CONTENTS директорий, которые после удаления
        тех или иных файлов больше не находятся на пути к тем файлам, которые
        по-прежнему принадлежат пакету.'''
        used_directories = set()
        not_directory_list = [path for path, value in
                              self.contents_dictionary.items()
                              if value['type'] != 'dir']
        for filepath in not_directory_list:
            file_directory = os.path.dirname(filepath)
            while file_directory != '/':
                used_directories.add(file_directory)
                file_directory = os.path.dirname(file_directory)

        paths_to_delete = [file_path for file_path, value in
                           self.contents_dictionary.items()
                           if value['type'] == 'dir' and
                           file_path not in used_directories]

        for file_path in paths_to_delete:
            self.contents_dictionary.pop(file_path)

    def get_md5(self, file_path):
        '''Метод для получения md5 хэш-суммы указанного файла.'''
        try:
            file_text = read_file(file_path).encode()
        except FilesError as error:
            raise PackageError(str(error))

        file_md5 = hashlib.md5(file_text).hexdigest()
        return file_md5

    def is_md5_equal(self, file_path, file_md5=None):
        '''Метод для проверки соответствия md5 хэш суммы файла той, что указана
        в файле CONTENTS.'''
        if file_md5 is None:
            file_md5 = self.get_md5(file_path)

        if self.chroot_path != "/" and file_path.startswith(self.chroot_path):
            file_path = file_path[len(self.chroot_path):]
        file_path = self.remove_cfg_prefix(file_path)

        contents_md5 = self.contents_dictionary[file_path]['md5']
        return file_md5 == contents_md5

    def __contains__(self, file_path):
        if self.chroot_path != "/" and file_path.startswith(self.chroot_path):
            file_path = file_path[len(self.chroot_path):]
        file_path = self.remove_cfg_prefix(file_path)

        return file_path in self.contents_dictionary

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