# Copyright (c) 2014 TrilioData, Inc.
# All Rights Reserved.

"""
Views for managing WorkloadMgr Workloads.
"""
import logging
from datetime import datetime

try:
    from django.core.urlresolvers import reverse
except ImportError:
    from django.urls import reverse
try:
    from django.core.urlresolvers import reverse_lazy
except ImportError:
    from django.urls import reverse_lazy
from django.utils.translation import gettext_lazy as _

from horizon import messages
from horizon import exceptions
from horizon import forms
from horizon import tables
from horizon import workflows
from horizon import messages
from horizon.utils import functions as horizon_utils

from openstack_dashboard import api
from trilio_dashboard import workloadmgr
from .tables import WorkloadsTable
from .snapshots.tables import SnapshotsTable
from .workflows import CreateWorkload
from .workflows import UpdateWorkload
from .workflows import CreateSnapshot
from .workflows import CreateTransferForm
from .workflows import AcceptTransferForm
from .workflows import ShowTransferForm

from django.views.generic import View
from django.http import HttpResponse, JsonResponse
import json
import ast

LOG = logging.getLogger(__name__)


class NextSnapshotView(View):
    """
        This will give Next Sanpshot Id.
    """
    def get(self, request):
        """

        Args:
            request: HttpRequest Object.

        Returns: Dict Next_snapshot_id

        """
        req = request.GET
        workload_id = req.get('workload_id')
        snapshot_id = req.get('snapshot_id')
        next_snap_id = workloadmgr.next_snapshot_by_id(request,
                                                       workload_id,
                                                       snapshot_id)
        return JsonResponse({"id": next_snap_id})


class PreviousSnapshotView(View):
    """
        This will give Previous Snapshot Id.
    """
    def get(self, request):
        """

        Args:
            request: HttpRequest Object

        Returns: dict Snapshot_id

        """
        req = request.GET
        workload_id = req.get('workload_id')
        snapshot_id = req.get('snapshot_id')
        next_snap_id = workloadmgr.prev_snapshot_by_id(request,
                                                       workload_id,
                                                       snapshot_id)
        return JsonResponse({"id": next_snap_id})

class SecretListView(View):
    """
        This will List Valid Secrets from KeyManager
    """
    def get(self, request):
        req = request.GET
        secrets = workloadmgr.secret_list(request)
        return JsonResponse(secrets)

class IndexView(tables.MultiTableView):
    table_class = WorkloadsTable
    table_classes = (WorkloadsTable,)
    template_name = 'project/workloads/index.html'

    def get_workloads_data(self):
        try:
            """if 'page' not in self.request.session:
                page_size = workloadmgr.page_size_get(self.request)
                self.request.session['page'] = page_size
            else:
                page_size = self.request.session['page']"""

            workloads = workloadmgr.workload_list(self.request)

            """id = self.request.GET.get('page',None)
            WorkloadsTable.has_more_data = True
            if id is None:
                WorkloadsTable.get_pagination_string  ="page=2"
                if len(workloads) < int(page_size):
                    WorkloadsTable.has_more_data = False
            else:
                if len(workloads) < int(page_size):
                    WorkloadsTable.get_pagination_string  ="page=1"
                else:
                    WorkloadsTable.get_pagination_string ="page="+str(int(id)+1)"""
        except Exception as ex:
            workloads = []
            msg = _('Workloads list can not be retrieved.')
            messages.error(self.request, msg)
            # exceptions.handle(self.request, msg)
        return workloads


class CreateView(workflows.WorkflowView):
    workflow_class = CreateWorkload
    template_name = 'project/workloads/create.html'

    def get_initial(self):
        pass


class UpdateView(workflows.WorkflowView):
    workflow_class = UpdateWorkload
    template_name = 'project/workloads/create.html'
    failure_url = reverse_lazy('horizon:project:workloads:index')

    def _get_data(self):
        if not hasattr(self, "_snapshot"):
            workload = None
            try:
                workload_id = self.kwargs['workload_id']
                workload = workloadmgr.workload_get(self.request, workload_id)
            except Exception as ex:
                msg = _('Unable to retrieve details for workload "%s". Reason: %s') \
                      % (workload_id, str(ex))
                messages.error(self.request, msg)  
                # exceptions.handle(self.request, msg, redirect=self.failure_url)
            self._workload = workload
        return self._workload

    def get_context_data(self, **kwargs):
        
        # set class specific attributes here
        # once super class method is called, it is too late
        workload = self._get_data()
        context = super(UpdateView, self).get_context_data(**kwargs)
        context['workload_id'] = self.kwargs['workload_id']
        context["workload"] = self._workload
        context['workflow'].context['workload_id'] = self.kwargs['workload_id']
        context["project_id"] = self._workload.project_id
        return context

    def get_initial(self):
        initial = super(UpdateView, self).get_initial()
        initial_values = {'workload_id': self.kwargs['workload_id'],
                         'name': self._workload.name,
                         'description': self._workload.description,
                         'workload_id': self._workload.id,
                         'instances': self._workload.instances,
                         'enabled': self._workload.jobschedule['enabled'],
                         'project_id':self._workload.project_id,
                         'jobschedule': {
                             'enabled': self._workload.jobschedule['enabled'],}}

        if self._workload.jobschedule['enabled'] == True:
            start_time = self._workload.jobschedule['start_time']

            format_string = '%I:%M%p'
            try:
                start_time = datetime.strptime(start_time, format_string)
            except:
                try:
                    format_string = '%I:%M %p'
                    start_time = datetime.strptime(start_time, format_string)
                except:
                    format_string = '%I:%M:%S'
                    start_time = datetime.strptime(start_time, format_string)

            initial_values.update({'start_date': self._workload.jobschedule['start_date'] or datetime.now().strftime('%m/%d/%Y'),
                               'end_date': 'end_date' in self._workload.jobschedule and \
                                           self._workload.jobschedule['end_date'] or "No End",
                               'start_time': start_time.strftime("%H:%M") or "9:00 PM",
                               'interval':'hourly' in self._workload.jobschedule and \
                                          self._workload.jobschedule['hourly'] and \
                                          'interval' in  self._workload.jobschedule['hourly'] and \
                                          self._workload.jobschedule['hourly'].get('interval') or "24",
                               'daily': 'daily' in self._workload.jobschedule and \
                                        self._workload.jobschedule['daily'] and \
                                        'backup_time' in  self._workload.jobschedule['daily'] and \
                                        self._workload.jobschedule['daily'].get('backup_time') or "23:00",
                               'weekly':'weekly' in self._workload.jobschedule and \
                                         self._workload.jobschedule['weekly'] and \
                                        'backup_day' in  self._workload.jobschedule['weekly'] and \
                                        self._workload.jobschedule['weekly'].get('backup_day') or "sun",
                               'monthly':'monthly' in self._workload.jobschedule and \
                                         self._workload.jobschedule['monthly'] and \
                                         'month_backup_day' in  self._workload.jobschedule['monthly'] and \
                                         self._workload.jobschedule['monthly'].get('month_backup_day') or "1",
                               'yearly':'yearly' in self._workload.jobschedule and \
                                       self._workload.jobschedule['yearly'] and \
                                        'backup_month' in  self._workload.jobschedule['yearly'] and \
                                        self._workload.jobschedule['yearly'].get('backup_month') or "dec",
                               'hourly_retention': 'hourly' in self._workload.jobschedule and \
                                       self._workload.jobschedule['hourly'] and \
                                       'retention' in self._workload.jobschedule['hourly'] and \
                                       self._workload.jobschedule['hourly'].get('retention') or "2"
                                        })
            initial_values['jobschedule'].update({
                               'start_date': self._workload.jobschedule['start_date'] or datetime.now().strftime('%m/%d/%Y'),
                               'end_date': 'end_date' in self._workload.jobschedule and \
                                           self._workload.jobschedule['end_date'] or "No End",
                               'start_time': start_time.strftime("%H:%M") or "9:00 PM",
                               'hourly': 'hourly' in self._workload.jobschedule and \
                                          self._workload.jobschedule['hourly'],
                               'daily': 'daily' in self._workload.jobschedule and \
                                        self._workload.jobschedule['daily'],
                               'weekly':'weekly' in self._workload.jobschedule and \
                                        self._workload.jobschedule['weekly'],
                               'monthly':'monthly' in self._workload.jobschedule and \
                                         self._workload.jobschedule['monthly'],
                               'yearly':'yearly' in self._workload.jobschedule and \
                                        self._workload.jobschedule['yearly'],
                               'manual':'manual' in self._workload.jobschedule and \
                                        self._workload.jobschedule['manual'],
                               'global_jobscheduler': self._workload.jobschedule['global_jobscheduler']
                               })
        initial.update(initial_values)
        return initial

class DetailView(tables.DataTableView):
    table_class = SnapshotsTable
    template_name = 'project/workloads/detail.html'
    failure_url = reverse_lazy('horizon:project:workloads:index')

    def get_data(self):
        snapshots = []
        try:
            workload = self._get_data()
            if workload:
                snapshots = workloadmgr.snapshot_list(self.request,
                                              workload_id=workload.id)
        except:
            msg = _('Snapshots list can not be retrieved.')
            # exceptions.handle(self.request, msg)
            messages.error(self.request, msg)
        return snapshots

    def _get_data(self):
        if not hasattr(self, "_workload"):
            workload = None
            try:
                workload_id = self.kwargs['workload_id']
                workload = workloadmgr.workload_get(self.request, workload_id)
                workload.trust = None
                scheduler_obj = workload.scheduler_trust.get('scheduler_obj')
                
                if workload.scheduler_trust.get('scheduler_enabled') and scheduler_obj:
                    workload.trust = workload.scheduler_trust.get('is_valid', False)
                    workload.user_id = scheduler_obj.get('user_id')
                    workload.project_id = scheduler_obj.get('project_id')

                if workload.jobschedule["enabled"]:
                    try:
                        datetime.strptime(workload.jobschedule['start_date'] + ' ' + workload.jobschedule['start_time'],
                                         "%m/%d/%Y %H:%M").strftime("%m/%d/%Y %I:%M %p")
                        start_date_time = workloadmgr.get_local_time(workload.jobschedule['start_date']+" "+workload.jobschedule['start_time'], "%m/%d/%Y %H:%M", "%m/%d/%Y %I:%M %p", horizon_utils.get_timezone(self.request)).split(" ")
                    except:
                        datetime.strptime(workload.jobschedule['start_date'] + ' ' + workload.jobschedule['start_time'],
                                          "%m/%d/%Y %I:%M %p").strftime("%m/%d/%Y %I:%M %p")
                        start_date_time = workloadmgr.get_local_time(workload.jobschedule['start_date']+" "+workload.jobschedule['start_time'], "%m/%d/%Y %I:%M %p", "%m/%d/%Y %I:%M %p", horizon_utils.get_timezone(self.request)).split(" ")

                    workload.jobschedule['start_date'] = start_date_time[0]
                    workload.jobschedule['start_time'] = ' '.join(start_date_time[1:])
            except:
                msg = _('Unable to retrieve details for workload "%s".') \
                      % (workload_id)
                messages.error(self.request, msg)  
                # exceptions.handle(self.request, msg, redirect=self.failure_url)
            self._workload = workload
            
        return self._workload
  
    def _get_snapshots(self, workload_id):
        try:
            snapshots = workloadmgr.snapshot_list(self.request,
                                              workload_id=workload_id, status="available",
                                              filter_it=False, get_instances=True)
            unique_vm_list = []
            unique_vm_list_info = []
            tz = workloadmgr.get_time_zone(self.request)
            for snapshot in snapshots:
                snapshot.size = workloadmgr.sizeof_fmt(snapshot.size)
                snapshot.created_at = workloadmgr.get_local_time(
                            snapshot.created_at, '', "%m/%d/%Y - %I:%M:%S %p", tz)
                if hasattr(snapshot, 'instances'):
                   for instance in snapshot.instances:
                       if instance['vm_id'] in unique_vm_list:
                          continue
                       unique_vm_list.append(instance['vm_id'])
                       d = {}
                       d['vm_name'] = instance['vm_name']
                       d['vm_id'] = instance['vm_id']
                       unique_vm_list_info.append(d)
        except:
               msg = _('Snapshots list can not be retrieved')
               messages.error(self.request, msg)
        return (snapshots, unique_vm_list, unique_vm_list_info)

    def get_context_data(self, **kwargs):
        context = super(DetailView, self).get_context_data(**kwargs)
        context["workload"] = self._get_data()
        snapshots, unique_vm_list, unique_vm_list_info = self._get_snapshots(context["workload"].id)
        context["snapshots"] = snapshots
        context["unique_vm_list"] = unique_vm_list
        context["unique_vm_list_info"] = unique_vm_list_info
        if len(snapshots) == 0 and len(unique_vm_list_info) == 0:
           for instance in context["workload"].instances:
               d = {}
               d['vm_name'] = instance['name']
               d['vm_id'] = instance['id']
               unique_vm_list_info.append(d)
        snapshot_list_by_vm = {}
        for vm in unique_vm_list:
            for snapshot in snapshots:
                if hasattr(snapshot, 'instances'):
                   for instance in snapshot.instances:
                       if instance['vm_id'] == vm:
                          lst = ""
                          if vm in snapshot_list_by_vm:
                             lst = snapshot_list_by_vm[vm]
                          if not snapshot.description:
                             snapshot.description = "-"
                          lst += snapshot.name+"&"+snapshot.id+"&"+snapshot.created_at+"&"+snapshot.snapshot_type+"&"+snapshot.status+"&"+str(snapshot.size)+"&"+snapshot.description+","
                          snapshot_list_by_vm[vm] = lst
                          break
        context["snapshot_list_by_vm"] = snapshot_list_by_vm
        return context


class SearchView(View):
    def post(self, request, *args, **kwargs):
        try:
            vm_id = request.POST['vm_id']
            filepath = request.POST['filepath']
            workload_id = request.POST['workload_id']
            snapshotids = []
            start = 0
            end = 0
            if 'snapshotids' in request.POST:
                snapshotids = request.POST.getlist('snapshotids')
            if 'start' in request.POST and request.POST['start'] != '' and request.POST['start'] > 0:
                start = request.POST['start']
            if 'end' in request.POST and request.POST['end'] != '' and request.POST['end'] > 0:
                end = request.POST['end']
            search = workloadmgr.file_search(request, vm_id, filepath, snapshotids, start, end)
            context = {'status': '200', 'search_id': search.id}
            response = HttpResponse(json.dumps(context), content_type='application/json')
            response.set_cookie(workload_id + '_search_id', search.id)
            return response
        except Exception as ex:
            context = {'status': '500', 'reason': str(ex)}
            return HttpResponse(json.dumps(context), content_type='application/json')

    def get(self, request, *args, **kwargs):
        try:
            search_id = list(request.GET.keys())[0]
            search = workloadmgr.file_search_show(request, search_id)
            output = ''
            sequence_list=["Permissions","Links","User ID","Group ID","Size","Created Time","Modified Time","Accessed Time"]
            if search.status == 'completed' and search.json_resp != '':
                snapshots = ast.literal_eval(search.json_resp)
                for snapshot in snapshots:
                    for key, value in list(snapshot.items()):
                        output_main = ''
                        table_head = ''
                        table_body = ''
                        output_main += '<h3 id="head_'+key+'" class="accordion-header ui-accordion-header ui-helper-reset ui-state-default ui-accordion-icons ui-corner-all"><span class="ui-accordion-header-icon ui-icon ui-icon-triangle-1-s"></span><span id="headspandate_'+key+'"></span>&nbsp;&nbsp;<span id="headspanname_'+key+'"></span> (<span style="font-style:italic;">' + key + '</span>)</h3><div class="ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom"><span><a style="float:right;color:#43a1d6;" target="_blank" href="../snapshots/'+key+'/detail">View Snapshot</a></span>'
                        i = 0
                        if isinstance(value, str):
                            output_main += '<p>' + value + '</p>'
                        else:
                            for drive in value:
                                if isinstance(drive, str):
                                    output_main += '<p>' + key + '<p>'
                                    output_main += '<p style="font-size:smaller;margin: 0% 5% 1%;font-weight: bold;">{}</p>'.format(drive)
                                    continue
                                for key1, value1 in list(drive.items()):
                                    if type(value1) is not list:  # check for last array of paths. Key is disk name
                                        continue
                                    output_main += '<p>' + key1 + '<p>'
                                    if len(value1) == 0:  # if no values in disk
                                        output_main += '<p style="font-size:smaller;margin: 0% 5% 1%;font-weight: bold;">No Matching Result.</p>'
                                        continue
                                    output_main += '<div class="metaTable"><table style="width:100%"><thead>'
                                    for sequence in sequence_list:
                                        output_main += '<th>'+sequence+'</th>'
                                    output_main +='<th>Path</th></thead><tbody>'
                                    for path in value1:  # Array of path names from main array drive
                                        #for key4, value4 in updated_meta.iteritems():  # fetch metadata from path name from drive array
                                        output_main += '<tr>'
                                        if type(drive.get(path, '')) == str:
                                           output_main+= '<td><div class="result_inline alert-danger">' +drive.get(path, '')+ '</div></td>'
                                        else:
                                            updated_meta = workloadmgr.convert_to_unix_format(drive.get(path, ''))
                                            for seq in updated_meta:
                                                output_main+= '<td><div class="result_inline">' +str(seq)+ '</div></td>'  # metadata value
                                        output_main += '<td><div class="result_inline">'+path+'</div></td></tr>'
                                    output_main += '</tr></tbody></table></div>'
                        output_main += '<div pull-right" style="padding: 4px 10px 0px 4px;">'
                        output_main += '<a class="btn ajax-modal btn-primary" style="float:right; text-decoration: none; color: white;" href="../snapshots/'+key+'/mount?step=mount_snapshot"> Mount Snapshot</a>'
                        output_main += '</div>'
                        output_main +='</div>'
                        output += output_main
            context = {'status': '200', 'sstatus': search.status, 'error_msg': search.error_msg,
                       'json_resp': search.json_resp, 'search_id': search_id, 'result': output,
                       'vm_id': search.vm_id, 'filepath': search.filepath}
            return HttpResponse(json.dumps(context), content_type='application/json')
        except Exception as ex:
            context = {'status': '500', 'reason': str(ex), 'search_id': search_id}
            return HttpResponse(json.dumps(context), content_type='application/json')

 
class CreateSnapshotView(workflows.WorkflowView):
    workflow_class = CreateSnapshot
    template_name = 'project/workloads/createsnapshot.html'

    def get_initial(self):
        pass


class CreateTransferView(forms.ModalFormView):
    form_class = CreateTransferForm
    template_name = 'project/workloads/create_transfer.html'
    success_url = reverse_lazy('horizon:project:workloads:index')
    modal_id = "create_workload_transfer_modal"
    modal_header = _("Create Workload Transfer")
    submit_label = _("Create Workload Transfer")
    submit_url = "horizon:project:workloads:create_transfer"
    page_title = _("Create a Workload Transfer")

    def get_context_data(self, *args, **kwargs):
        context = super(CreateTransferView, self).get_context_data(**kwargs)
        workload_id = self.kwargs['workload_id']
        context['workload_id'] = workload_id
        context['submit_url'] = reverse(self.submit_url, args=[workload_id])
        return context

    def get_initial(self):
        return {'workload_id': self.kwargs["workload_id"]}


class AcceptTransferView(forms.ModalFormView):
    form_class = AcceptTransferForm
    template_name = 'project/workloads/accept_transfer.html'
    success_url = reverse_lazy('horizon:project:workloads:index')
    modal_id = "accept_workload_transfer_modal"
    modal_header = _("Accept Workload Transfer")
    submit_label = _("Accept Workload Transfer")
    submit_url = reverse_lazy(
        "horizon:project:workloads:accept_transfer")
    page_title = _("Accept Workload Transfer")


class ShowTransferView(forms.ModalFormView):
    form_class = ShowTransferForm
    template_name = 'project/workloads/show_transfer.html'
    success_url = reverse_lazy('horizon:project:workloads:index')
    modal_id = "show_workload_transfer_modal"
    modal_header = _("Workload Transfer")
    submit_url = "horizon:project:workloads:show_transfer"
    cancel_label = _("Close")
    page_title = _("Workload Transfer Details")

    def get_object(self):
        try:
            return self._object
        except AttributeError:
            transfer_id = self.kwargs['transfer_id']
            try:
                self._object = workloadmgr.transfer_get(self.request, transfer_id)
                return self._object
            except Exception:
                exceptions.handle(self.request,
                                  _('Unable to retrieve workload transfer.'))

    def get_context_data(self, **kwargs):
        context = super(ShowTransferView, self).get_context_data(**kwargs)
        context['transfer_id'] = self.kwargs['transfer_id']
        context['auth_key'] = self.kwargs['auth_key']
        context['submit_url'] = reverse(self.submit_url, args=[
            context['transfer_id'], context['auth_key']])
        return context

    def get_initial(self):
        transfer = self.get_object()
        return {'id': transfer.id,
                'name': transfer.name,
                'auth_key': self.kwargs['auth_key']}


class CheckWorkloadView(View):

    def get(self, request, *args, **kwargs):
        try:
            not_found = False
            workload_id = kwargs['workload_id']
            try:
                workload = workloadmgr.workload_get(request, workload_id)
            except:
                   not_found = True
            if not_found is True:
               context = {'status': '200', 'reason': 'Deleted'}
               return HttpResponse(json.dumps(context), content_type='application/json')
            else:
                 raise Exception("Not Deleted")
        except Exception as ex:
            context = {'status': '500', 'reason': str(ex)}
            return HttpResponse(json.dumps(context), content_type='application/json')

class PolicyDetailsView(View):
    def get(self, request, *args, **kwargs):
        try:
            policy_id = list(request.GET.keys())[0] 
            policy_details = workloadmgr.get_policy(request,policy_id)
            field_values = policy_details.field_values
            for info in field_values:
                field_name = info['policy_field_name']
                setattr(policy_details, field_name, info['value'])

            policy_details.__delattr__('manager')
            context = {'status': '200','data':policy_details.__dict__}
            # fixing parsing errors
            context = ast.literal_eval(str(context).replace('"[', '[').replace(']"',']').replace("'[]'", "[]"))
            response = HttpResponse(json.dumps(context), content_type='application/json')
            return response
        except Exception as ex:
            context = {'status': '500', 'reason': str(ex)}
            return HttpResponse(json.dumps(context), content_type='application/json')


class CheckBttImmutabilityView(View):
    def get(self, request, *args, **kwargs):
        invalid_ids=[]
        try:
            btt_name = request.GET['btt_name']
            is_immutable = workloadmgr.is_btt_immutable(request, btt_name)
            data = {'status': '200', 'state': is_immutable.get("status")}
            return HttpResponse(json.dumps(data), content_type="application/json")
        except Exception as ex:
            data = {'status': '500', 'reason': str(ex)}
            return HttpResponse(json.dumps(data), content_type="application/json")