import os

import re

import json

import stat

import tempfile

from datetime import datetime

from io import StringIO

from django.db import transaction

from collections import OrderedDict

from django.conf import settings

from distutils.version import LooseVersion as Version

from django.core.management.base import BaseCommand

from cyborgbackup.main.models import Job, Repository, Catalog

from cyborgbackup.main.expect import run

from cyborgbackup.main.models.settings import Setting

from cyborgbackup.main.utils.common import get_ssh_version

from cyborgbackup.main.utils.encryption import decrypt_field

OPENSSH_KEY_ERROR = u'''\

class Command(BaseCommand):

    help = 'Rebuild Catalog from all Repositories.'

    cleanup_paths = []

    def get_password_prompts(self, **kwargs):

        d = OrderedDict()

        for k, v in kwargs['passwords'].items():

            d[re.compile(r'Enter passphrase for .*'+k+r':\s*?$', re.M)] = k

            d[re.compile(r'Enter passphrase for .*'+k, re.M)] = k

        d[re.compile(r'Bad passphrase, try again for .*:\s*?$', re.M)] = ''

        return d

    def get_ssh_key_path(self, instance, **kwargs):

        private_data_files = kwargs.get('private_data_files', {})

        if 'ssh' in private_data_files.get('credentials', {}):

            return private_data_files['credentials']['ssh']

        return ''

    def build_passwords(self, job, **kwargs):

        passwords = {}

        for setting in Setting.objects.filter(key__contains='ssh_key'):

            set = Setting.objects.get(key=setting.key.replace('ssh_key', 'ssh_password'))

            passwords['credential_{}'.format(setting.key)] = decrypt_field(set, 'value')

        return passwords

    def build_private_data(self, instance, **kwargs):

        private_data = {'credentials': {}}

        for sets in Setting.objects.filter(key__contains='ssh_key'):

            private_data['credentials'][sets] = decrypt_field(sets, 'value') or ''

        return private_data

    def build_private_data_dir(self, instance, **kwargs):

        path = tempfile.mkdtemp(prefix='cyborgbackup_%s_' % instance.pk, dir='/tmp/')

        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)

        self.cleanup_paths.append(path)

        return path

    def build_private_data_files(self, instance, **kwargs):

        private_data = self.build_private_data(instance, **kwargs)

        private_data_files = {'credentials': {}}

        if private_data is not None:

            ssh_ver = get_ssh_version()

            ssh_too_old = True if ssh_ver == "unknown" else Version(ssh_ver) < Version("6.0")

            openssh_keys_supported = ssh_ver != "unknown" and Version(ssh_ver) >= Version("6.5")

            for sets, data in private_data.get('credentials', {}).items():

                if 'OPENSSH PRIVATE KEY' in data and not openssh_keys_supported:

                    raise RuntimeError(OPENSSH_KEY_ERROR)

            listpaths = []

            for sets, data in private_data.get('credentials', {}).items():

                if 'OPENSSH PRIVATE KEY' in data and not data.endswith('\n'):

                    data += '\n'

                if sets and not ssh_too_old:

                    name = 'credential_{}'.format(sets.key)

                    path = os.path.join(kwargs['private_data_dir'], name)

                    run.open_fifo_write(path, data)

                    listpaths.append(path)

            if len(listpaths) > 1:

                private_data_files['credentials']['ssh'] = listpaths

            elif len(listpaths) == 1:

                private_data_files['credentials']['ssh'] = listpaths[0]

        return private_data_files

    def launch_command(self, cmd, instance, key, path, **kwargs):

        cwd = '/tmp/'

        env = {}

        env['BORG_PASSPHRASE'] = key

        env['BORG_REPO'] = path

        env['BORG_RELOCATED_REPO_ACCESS_IS_OK'] = 'yes'

        env['BORG_RSH'] = 'ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null'

        args = cmd

        safe_args = args

        kwargs['private_data_dir'] = self.build_private_data_dir(instance, **kwargs)

        kwargs['private_data_files'] = self.build_private_data_files(instance, **kwargs)

        kwargs['passwords'] = self.build_passwords(instance, **kwargs)

        expect_passwords = {}

        for k, v in self.get_password_prompts(**kwargs).items():

            expect_passwords[k] = kwargs['passwords'].get(v, '') or ''

        _kw = dict(

        stdout_handle = StringIO()

        ssh_key_path = self.get_ssh_key_path(instance, **kwargs)

        if ssh_key_path:

            ssh_auth_sock = os.path.join(kwargs['private_data_dir'], 'ssh_auth.sock')

            args = run.wrap_args_with_ssh_agent(args, ssh_key_path, ssh_auth_sock)

            safe_args = run.wrap_args_with_ssh_agent(safe_args, ssh_key_path, ssh_auth_sock)

        status, rc = run.run_pexpect(

        lines = stdout_handle.getvalue().splitlines()

        return lines

    def handle(self, *args, **kwargs):

        jobs = Job.objects.filter(status="running")

        if jobs.exists():

            print('A job is already running, exiting.')

            return

        repos = Repository.objects.filter(enabled=True)

        repoArchives = []

        if repos.exists():

            for repo in repos:

                lines = self.launch_command(["borg", "list", "::"], repo, repo.repository_key, repo.path, **kwargs)

                for line in lines:

                    archive_name = line.split(' ')[0]  #

                    for type in ('rootfs', 'vm', 'mysql', 'postgresql', 'config', 'piped', 'mail', 'folders'):

                        if '{}-'.format(type) in archive_name:

                            repoArchives.append(archive_name)

            entries = Job.objects.filter(job_type='job', status='successful')

            if entries.exists():

                for entry in entries:

                    if entry.archive_name != '' and entry.archive_name not in repoArchives:

                        print('Delete {} from catalog'.format(entry.archive_name))

                        Catalog.objects.filter(archive_name=entry.archive_name).delete()

                        entry.archive_name = ''

                        entry.save()

            for repo in repos:

                jobs = Job.objects.filter(policy__repository_id=repo.pk,

                if jobs.exists():

                    for job in jobs:

                        if job.archive_name \

                            lines = self.launch_command(["borg",

                            hoursTimezone = round((round((datetime.now()-datetime.utcnow()).total_seconds())/1800)/2)

                            with transaction.atomic():

                                for line in lines:

                                    try:

                                        data = json.loads(line)

                                        entries = Catalog.objects.filter(archive_name=job.archive_name,

                                        if not entries.exists():

                                            entry = Catalog()

                                            entry.path = data['path']

                                            entry.job = job

                                            entry.archive_name = job.archive_name

                                            entry.mode = data['mode']

                                            entry.owner = data['user']

                                            entry.group = data['group']

                                            entry.type = data['type']

                                            entry.size = data['size']

                                            entry.healthy = data['healthy']

                                            entry.mtime = '{}+0{}00'.format(data['mtime'].replace('T', ' '),

                                            entry.save()

                                    except Exception as e:

                                        print(e)

                                        continue