import os

import re

import stat

import shutil

import tempfile

from io import StringIO

from collections import OrderedDict

from django.conf import settings

from elasticsearch import Elasticsearch

from distutils.version import LooseVersion as Version

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

from django.core.management.base import BaseCommand

from django.db import transaction

from cyborgbackup.main.models import Job, Repository

es_conf = settings.ELASTICSEARCH_DSL['default']['hosts'].split(':')

es = Elasticsearch([{'host': es_conf[0], 'port': int(es_conf[1])}])

OPENSSH_KEY_ERROR = u'''\

class Command(BaseCommand):

    help = 'Remove old jobs from the database.'

    cleanup_paths = []

    def add_arguments(self, parser):

        parser.add_argument('--dry-run', dest='dry_run', action='store_true',

        parser.add_argument('--jobs', dest='only_jobs', action='store_true',

    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()

        shutil.rmtree(kwargs['private_data_dir'])

        return lines

    def cleanup_jobs(self):

        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)

                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)

                print(repoArchives)

                entries = Job.objects.filter(job_type='job')

                if entries.exists():

                    for entry in entries:

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

                            action_text = 'would delete' if self.dry_run else 'deleting'

                            print('{} {}'.format(action_text, entry.archive_name))

                            if not self.dry_run:

                                es.delete_by_query(index="catalog", doc_type='_doc',

                                entry.delete()

        return 0, 0

    @transaction.atomic

        self.verbosity = int(options.get('verbosity', 1))

        self.dry_run = bool(options.get('dry_run', False))

        model_names = ('jobs',)

        models_to_cleanup = set()

        for m in model_names:

            if options.get('only_%s' % m, False):

                models_to_cleanup.add(m)

        if not models_to_cleanup:

            models_to_cleanup.update(model_names)

        for m in model_names:

            if m in models_to_cleanup:

                skipped, deleted = getattr(self, 'cleanup_%s' % m)()

                if self.dry_run:

                    print('{}: {} would be deleted, {} would be skipped.'.format(m.replace('_', ' '),

                    print('{}: {} deleted, {} skipped.'.format(m.replace('_', ' '), deleted, skipped))