#!/usr/bin/env python3
#
# Copyright 2023 Marek Marczykowski-Górecki <marmarek@invisiblethingslab.com>
#
# SPDX-License-Identifier: LGPL-2.1-or-later

import grp
import re
import os

EXIT_CODES = {"ERROR": 1, "SUCCESS": 0, "NOTHING_TO_DO": 2}

WARNING_COLOR = "\033[93m"


def create_dirs(*args):
    """Method creates directories.

    Keyword arguments:
    *args -- paths to be created
    """
    qubes_gid = grp.getgrnam("qubes").gr_gid
    old_umask = os.umask(0o002)
    if args is None:
        raise Exception("Creating directories failed, no paths given.")
    for file_path in args:
        if not os.path.exists(file_path):
            os.makedirs(file_path)
            os.chown(file_path, -1, qubes_gid)
        elif os.stat(file_path).st_gid != qubes_gid:
            print(
                f"{WARNING_COLOR}Warning: You should move a personal files"
                f" from {file_path}. Cleaning cache will cause lose of "
                f"the personal data!!{WARNING_COLOR}"
            )
    os.umask(old_umask)


class LooseVersion:
    """Version numbering for anarchists and software realists.
    Implements the standard interface for version number classes as
    described above.  A version number consists of a series of numbers,
    separated by either periods or strings of letters.  When comparing
    version numbers, the numeric components will be compared
    numerically, and the alphabetic components lexically.  The following
    are all valid version numbers, in no particular order:

        1.5.1
        1.5.2b2
        161
        3.10a
        8.02
        3.4j
        1996.07.12
        3.2.pl0
        3.1.1.6
        2g6
        11g
        0.960923
        2.2beta29
        1.13++
        5.5.kw
        2.0b1pl0

    In fact, there is no such thing as an invalid version number under
    this scheme; the rules for comparison are simple and predictable,
    but may not always give the results you want (for some definition
    of "want").
    """

    component_re = re.compile(r"(\d+ | [a-z]+ | \.)", re.VERBOSE)

    def __init__(self, vstring=None):
        if vstring:
            self.parse(vstring)

    def parse(self, vstring):
        # I've given up on thinking I can reconstruct the version string
        # from the parsed tuple -- so I just store the string here for
        # use by __str__
        self.vstring = vstring
        components = [x for x in self.component_re.split(vstring) if x and x != "."]
        for i, obj in enumerate(components):
            try:
                components[i] = int(obj)
            except ValueError:
                pass

        self.version = components

    def __str__(self):
        return self.vstring

    def __repr__(self):
        return f"LooseVersion ('{str(self)}')"

    def _cmp(self, other):
        if isinstance(other, str):
            other = LooseVersion(other)
        elif not isinstance(other, LooseVersion):
            return NotImplemented

        if self.version == other.version:
            return 0
        if self.version < other.version:
            return -1
        if self.version > other.version:
            return 1

    def __eq__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c == 0

    def __lt__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c < 0

    def __le__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c <= 0

    def __gt__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c > 0

    def __ge__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c >= 0
