import json
import logging

from app_be.services.dropboxservice import DropboxService
from app_be.services.hashservice import create_sha512
from app_be.services.minioservice import MinioService
from app_be.services.mongodbservice import MongoDBService
from app_be.services.wrapperservice import WrapperService
from django.http import HttpRequest
from django.http import JsonResponse
from rest_framework.decorators import api_view

logger = logging.getLogger(__name__)


class TestApiClass:
    @staticmethod
    @api_view(['GET'])
    def test_api(request):
        logger.debug('Test api call: {}'.format(request))
        return JsonResponse({'Result': 'success'}, safe=False)


class ImageEndpoint:

    storageServiceList = [DropboxService, MinioService]

    @staticmethod
    @api_view(['GET'])
    def image_api_get_all(request):
        logger.debug('Image GET all call: {}'.format(request))
        print(request)

        metadata = MongoDBService.getAll()
        print(metadata)

        return JsonResponse({'Result': 'success1'}, safe=False)

    @staticmethod
    @api_view(['GET'])
    def image_api_get_single(request, identifier):
        logger.debug('Image GET single call: {}'.format(request))

        # get metadata from MongoDB
        metadata = MongoDBService.getSingle(identifier)
        if not metadata:
            return JsonResponse({'Result': 'Error - could not find any metadata in mongoDB.',
                                 'id': identifier}, status=404, safe=False)
        logger.debug('Mongo Meta: {}'.format(metadata))

        # get stored SHA512 hash
        stored_hash = metadata.get('sha512', '')
        logger.debug('Sorted SHA512: {}'.format(stored_hash))
        service_image_bytes = None
        for service in ImageEndpoint.storageServiceList:
            logger.debug('Checking hash for ' + service.name)
            # get image bytes from Dropbox
            service_image_bytes = service.read_file(metadata['filename'])
            if service_image_bytes is None:
                return JsonResponse({'Result': 'Error - could not find image in ' + service.name, 'id': identifier},
                                    status=404, safe=False)

            # calc dropbox image hash
            actual_service_hash = create_sha512(service_image_bytes)
            logger.debug('Actual '+service.name+' SHA512: {}'.format(actual_service_hash))
            if stored_hash != actual_service_hash:
                return JsonResponse('Stored hash in service "'+service.name+'"does not match generated one! '
                                    'stored: {} actual: {}'.format(stored_hash, actual_service_hash),
                                    status=400, safe=False)

        payload = {
            'id': identifier,
            'metadata': metadata,
            'image_data': WrapperService.wrap_file(service_image_bytes)
        }

        return JsonResponse(payload, safe=False)

    @staticmethod
    @api_view(['POST'])
    def image_api_post(request: HttpRequest):
        logger.debug('Image POST call: {}'.format(request))
        payload = json.loads(request.body)
        b64encoded_image = payload['image_data']
        identifier = payload['id']
        metadata = payload['metadata']
        filename = payload['metadata']['filename']

        decoded_image = WrapperService.unwrap_file(b64encoded_image)

        if not MongoDBService.createSingle(metadata, identifier, decoded_image):
            print("Could not save metadata")
            return JsonResponse({'Result': 'Error - could not upload to MongoDB', 'id': identifier, 'filename': filename},status=500,safe=False)

        for service in ImageEndpoint.storageServiceList:
            if not service.create_file(filename, decoded_image):
                print("Could not save image to " + service.name)
                return JsonResponse({'Result': 'Error - could not upload to ' + service.name, 'id': identifier, 'filename': filename},status=500, safe=False)

        return JsonResponse({'id': identifier, 'filename': filename},safe=False)

    @staticmethod
    @api_view(['DELETE'])
    def image_api_delete(request: HttpRequest, identifier):

        logger.debug('Image DELETE single call: {}'.format(request))
        result_bool = True

        # get metadata from MongoDB
        metadata = MongoDBService.getSingle(identifier)

        if not metadata:
            return JsonResponse({'Result': 'Error - could not find any metadata in mongoDB.',
                                 'id': identifier}, status=404, safe=False)

        resp = MongoDBService.deleteSingle(identifier)
        print(resp)

        for service in ImageEndpoint.storageServiceList:
            if not service.delete_file(metadata['filename']):
                print('Error deleting file in ' + service.name)
                result_bool = False

        return JsonResponse({'Result': result_bool}, safe=False)

    @staticmethod
    @api_view(['DELETE'])
    def image_api_delete_all(request: HttpRequest):

        logger.debug('Image DELETE single call: {}'.format(request))
        result_bool = True

        resp = MongoDBService.deleteAll()
        print(resp)

        for service in ImageEndpoint.storageServiceList:
            if not service.delete_all():
                print('Error deleting ' + service.name + ' folder')
                result_bool = False

        return JsonResponse({'Result': result_bool}, safe=False)

    @staticmethod
    @api_view(['PUT'])
    def image_api_update(request, identifier):

        logger.debug('Image UPDATE single call: {}'.format(request))

        # get metadata from MongoDB
        metadata = MongoDBService.getSingle(identifier)
        if not metadata:
            return JsonResponse({'Result': 'Error - Could not find image to be updated',
                                 'id': identifier}, status=404, safe=False)

        for service in ImageEndpoint.storageServiceList:
            service.delete_file(metadata['filename'])

        MongoDBService.deleteSingle(identifier)


        payload = json.loads(request.body)
        b64encoded_image = payload['image_data']
        identifier = payload['id']
        metadata = payload['metadata']
        filename = payload['metadata']['filename']

        decoded_image = WrapperService.unwrap_file(b64encoded_image)

        MongoDBService.createSingle(metadata, identifier, decoded_image)

        for service in ImageEndpoint.storageServiceList:
            if not service.create_file(filename, decoded_image):
                print("Could not save image to " + service.name)

        return JsonResponse({'id': identifier, 'filename': filename},
                            safe=False)


class HealthEndpoint:

    storageServiceList = [DropboxService, MinioService]

    @staticmethod
    @api_view(['GET'])
    def check_systems(request):
        logger.debug('Check health of all sub-systems')
        response = {'MongoDB': MongoDBService.check()}
        for service in HealthEndpoint.storageServiceList:
            response[service.name] = service.check()

        return JsonResponse(response, safe=False)