# -*- coding: utf-8 -*-


# Create your views here.
import json

from django.shortcuts import redirect
from django.http import HttpResponse

from backup.backupManager import BackupManager
from backup.pluginManager import pluginManager
from loginSystem.views import loadLoginPage
import os
from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
from django.views.decorators.csrf import csrf_exempt
from django.contrib.auth.models import User
from loginSystem.models import Administrator

def loadBackupHome(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.loadBackupHome(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def backupSite(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.backupSite(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def gDrive(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.gDrive(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def gDriveSetup(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.gDriveSetup(userID, request)
    except KeyError:
        return redirect(loadLoginPage)

def fetchgDriveSites(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.fetchgDriveSites(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def addSitegDrive(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.addSitegDrive(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def deleteAccountgDrive(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.deleteAccountgDrive(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def changeAccountFrequencygDrive(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.changeAccountFrequencygDrive(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def changeFileRetention(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.changeFileRetention(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def deleteSitegDrive(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.deleteSitegDrive(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def fetchDriveLogs(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.fetchDriveLogs(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def restoreSite(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.restoreSite(request, userID)
    except KeyError:
        return redirect(loadLoginPage)


def getCurrentBackups(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.getCurrentBackups(userID, json.loads(request.body))
    except KeyError:
        return redirect(loadLoginPage)

def submitBackupCreation(request):
    try:
        userID = request.session['userID']

        result = pluginManager.preSubmitBackupCreation(request)
        if result != 200:
            return result

        wm = BackupManager()
        coreResult =  wm.submitBackupCreation(userID, json.loads(request.body))

        return coreResult

    except BaseException as msg:
        logging.writeToFile(str(msg))


def backupStatus(request):
    try:
        userID = 1
        wm = BackupManager()
        return wm.backupStatus(userID, json.loads(request.body))
    except KeyError:
        return redirect(loadLoginPage)


def cancelBackupCreation(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.cancelBackupCreation(userID, json.loads(request.body))
    except KeyError:
        return redirect(loadLoginPage)


def deleteBackup(request):
    try:
        userID = request.session['userID']

        result = pluginManager.preDeleteBackup(request)
        if result != 200:
            return result

        wm = BackupManager()
        coreResult = wm.deleteBackup(userID, json.loads(request.body))

        result = pluginManager.postDeleteBackup(request, coreResult)
        if result != 200:
            return result

        return coreResult

    except KeyError:
        return redirect(loadLoginPage)


def submitRestore(request):
    try:
        userID = request.session['userID']
        result = pluginManager.preSubmitRestore(request)
        if result != 200:
            return result

        wm = BackupManager()
        coreResult = wm.submitRestore(json.loads(request.body), userID)

        return coreResult
    except KeyError:
        return redirect(loadLoginPage)


def restoreStatus(request):
    try:
        wm = BackupManager()
        return wm.restoreStatus(json.loads(request.body))
    except KeyError:
        return redirect(loadLoginPage)


def backupDestinations(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.backupDestinations(request, userID)
    except KeyError:
        return redirect(loadLoginPage)


def submitDestinationCreation(request):
    try:
        userID = request.session['userID']

        result = pluginManager.preSubmitDestinationCreation(request)
        if result != 200:
            return result

        wm = BackupManager()
        coreResult = wm.submitDestinationCreation(userID, json.loads(request.body))

        result = pluginManager.postSubmitDestinationCreation(request, coreResult)
        if result != 200:
            return result

        return coreResult
    except KeyError:
        return redirect(loadLoginPage)

def getCurrentBackupDestinations(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.getCurrentBackupDestinations(userID, json.loads(request.body))
    except KeyError:
        return redirect(loadLoginPage)

def getConnectionStatus(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.getConnectionStatus(userID, json.loads(request.body))
    except KeyError:
        return redirect(loadLoginPage)

def deleteDestination(request):
    try:
        userID = request.session['userID']
        result = pluginManager.preDeleteDestination(request)
        if result != 200:
            return result

        wm = BackupManager()
        coreResult = wm.deleteDestination(userID, json.loads(request.body))

        result = pluginManager.postDeleteDestination(request, coreResult)
        if result != 200:
            return result

        return coreResult
    except KeyError:
        return redirect(loadLoginPage)

def scheduleBackup(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.scheduleBackup(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def getCurrentBackupSchedules(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.getCurrentBackupSchedules(userID, json.loads(request.body))
    except KeyError:
        return redirect(loadLoginPage)

def submitBackupSchedule(request):
    try:
        userID = request.session['userID']
        result = pluginManager.preSubmitBackupSchedule(request)
        if result != 200:
            return result

        wm = BackupManager()
        coreResult = wm.submitBackupSchedule(userID, json.loads(request.body))

        result = pluginManager.postSubmitBackupSchedule(request, coreResult)
        if result != 200:
            return result

        return coreResult
    except KeyError:
        return redirect(loadLoginPage)

def scheduleDelete(request):
    try:
        userID = request.session['userID']
        result = pluginManager.preScheduleDelete(request)
        if result != 200:
            return result

        wm = BackupManager()
        coreResult = wm.scheduleDelete(userID, json.loads(request.body))

        result = pluginManager.postScheduleDelete(request, coreResult)
        if result != 200:
            return result

        return coreResult
    except KeyError:
        return redirect(loadLoginPage)

def remoteBackups(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.remoteBackups(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def submitRemoteBackups(request):
    try:
        userID = request.session['userID']
        result = pluginManager.preSubmitRemoteBackups(request)
        if result != 200:
            return result

        wm = BackupManager()
        coreResult = wm.submitRemoteBackups(userID, json.loads(request.body))

        result = pluginManager.postSubmitRemoteBackups(request, coreResult)
        if result != 200:
            return result

        return coreResult
    except KeyError:
        return redirect(loadLoginPage)

def starRemoteTransfer(request):
    try:
        userID = request.session['userID']
        result = pluginManager.preStarRemoteTransfer(request)
        if result != 200:
            return result

        wm = BackupManager()
        coreResult = wm.starRemoteTransfer(userID, json.loads(request.body))

        result = pluginManager.postStarRemoteTransfer(request, coreResult)
        if result != 200:
            return result

        return coreResult
    except KeyError:
        return redirect(loadLoginPage)

def getRemoteTransferStatus(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.getRemoteTransferStatus(userID, json.loads(request.body))
    except KeyError:
        return redirect(loadLoginPage)

def remoteBackupRestore(request):
    try:
        userID = request.session['userID']
        result = pluginManager.preRemoteBackupRestore(request)
        if result != 200:
            return result

        wm = BackupManager()
        coreResult = wm.remoteBackupRestore(userID, json.loads(request.body))

        result = pluginManager.postRemoteBackupRestore(request, coreResult)
        if result != 200:
            return result

        return coreResult
    except KeyError:
        return redirect(loadLoginPage)

def localRestoreStatus(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.localRestoreStatus(userID, json.loads(request.body))
    except KeyError:
        return redirect(loadLoginPage)

def cancelRemoteBackup(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.cancelRemoteBackup(userID, json.loads(request.body))
    except KeyError:
        return redirect(loadLoginPage)

def backupLogs(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.backupLogs(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def fetchLogs(request):
    try:
        userID = request.session['userID']

        wm = BackupManager()
        return wm.fetchLogs(userID, json.loads(request.body))

    except KeyError:
        return redirect(loadLoginPage)

@csrf_exempt
def localInitiate(request):
    try:
        data = json.loads(request.body)
        randomFile = data['randomFile']

        try:
            randInt = int(randomFile)
            pathToFile = "/home/cyberpanel/" + randomFile

            if os.path.exists(pathToFile):
                wm = BackupManager()
                return wm.submitBackupCreation(1, json.loads(request.body))
        except:
            pass
    except BaseException as msg:
        logging.writeToFile(str(msg))

def fetchgNormalSites(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.fetchgNormalSites(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def fetchNormalJobs(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.fetchNormalJobs(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def addSiteNormal(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.addSiteNormal(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def deleteSiteNormal(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.deleteSiteNormal(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def changeAccountFrequencyNormal(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.changeAccountFrequencyNormal(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def deleteAccountNormal(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.deleteAccountNormal(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def fetchNormalLogs(request):
    try:
        userID = request.session['userID']
        wm = BackupManager()
        return wm.fetchNormalLogs(request, userID)
    except KeyError:
        return redirect(loadLoginPage)


def OneClickBackups(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.OneClickBackups(request, userID)
    except KeyError:

        return redirect(loadLoginPage)

def ManageOCBackups(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.ManageOCBackups(request, userID)
    except KeyError:

        return redirect(loadLoginPage)

def RestoreOCBackups(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.RestoreOCBackups(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def fetchOCSites(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.fetchOCSites(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def StartOCRestore(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.StartOCRestore(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def DeployAccount(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        return bm.DeployAccount(request, userID)
    except KeyError:
        return redirect(loadLoginPage)

def ReconfigureSubscription(request):
    try:
        userID = request.session['userID']
        bm = BackupManager()
        data = json.loads(request.body)
        return bm.ReconfigureSubscription(request, userID, data)
    except BaseException as msg:
        data_ret = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(data_ret)
        return HttpResponse(json_data)