@csrf_exempt
@login_required(login_url=reverse_lazy('login'))
def upload(request):
    from richtext.importing import source_handler

    # Check if the subscription allows uploading

    allow, _ = has_permission(request, 'app_upload')
    if not allow:
        # TODO: Toast the msg somehow
        logging.warning('%s tried to upload without proper subscription' % request.user)
        return HttpResponse(json.dumps({'document': None}),
                            content_type='application/json',
                            status=403)

    # Get POST parameters
    source = request.POST.get('filesource')
    file_url = request.POST.get('fileurl')
    file_name = request.POST.get('file_name')
    access_token = request.POST.get('accessToken')

    if re.findall(".zip", file_name):
        uploaded_zip = save_zip_from_request(file_name, request.FILES.get('file'))
        with zipfile.ZipFile(uploaded_zip, "r") as zip_instance:
            batch = BatchUpload.objects.create(
                batch_type="Archive",
                name=file_name,
                documents_count=len(zip_instance.namelist()),
                owner=request.user)

        to_massage = {'uploaded_doc': [

        ]}

        try:
            with zipfile.ZipFile(uploaded_zip, "r") as archive:
                for file_in_archive in archive.namelist():
                    with archive.open(file_in_archive, 'r') as f:
                        document_to_analyze(f, file_in_archive, user=request.user, source="local", batch=batch)
                        to_massage['uploaded_doc'].append({'document': str(file_in_archive)})
        except RuntimeError:
            archive_instance = Archive.objects.create(
                name=file_name,
                path=uploaded_zip,
                is_encrypted=True
            )
            batch.delete()

            return HttpResponse(json.dumps({
                'encrypted': True,
                'id': archive_instance.id
            }), content_type='application/json')
        NotificationManager.create_user_message(request.user, "Uploaded", to_massage).send()
        return HttpResponse(json.dumps({
            'document': str(file_name)
        }), content_type='application/json')

    else:
        # TODO Change documents_count to work with files lists (after drag&drop batch will work)
        batch = BatchUpload.objects.create(
            batch_type="Archive",
            name=file_name,
            documents_count=1,
            owner=request.user)
        # Get the uploaded file
        uploaded_file = request.FILES.get('file')

        logging.info('Uploading file from source=%s' % str(source))

        # Get the proper uploader
        uploader = source_handler(source)

        # Process the upload request
        is_success, payload = uploader.process(uploaded_file=uploaded_file,
                                               file_url=file_url,
                                               file_name=file_name,
                                               access_token=access_token)

        # Something went wrong during the file processing, refresh
        if not is_success:
            msg = payload
            logging.warning('Upload failed msg=%s' % msg)
            # TODO: Toast the msg somehow
            return redirect(reverse('upload_file'))

        original_filename, temp_file_handle = payload
        title = remove_extension(original_filename).replace('_', ' ')

        # Save locally
        temp_path = default_storage.save(str(uuid.uuid4()), ContentFile(temp_file_handle.read()))
        temp_filename = os.path.join(settings.MEDIA_ROOT, temp_path)

        document = Document.analysis_workflow_start(uploader=request.user,
                                                    file_path=temp_filename,
                                                    upload_source=source,
                                                    original_filename=original_filename,
                                                    title=title,
                                                    is_from_batch=True,
                                                    to_batch_upload=batch
                                                    )

        return HttpResponse(json.dumps({
            'document': document.to_dict(include_analysis=False, include_raw=False)
        }), content_type='application/json')


@csrf_exempt
@login_required(login_url=reverse_lazy('login'))
def process_encrypted_archive(request):
    allow, _ = has_permission(request, 'app_upload')

    if not allow:
        logging.warning('%s tried to get without proper subscription' % request.user)
        return HttpResponse(content_type='application/json',
                            status=403)

    archive_id = request.POST["id"]
    password = str(request.POST["password"])

    instance = Archive.objects.get(id=archive_id)
    to_massage = {'uploaded_doc': [

    ]}
    with zipfile.ZipFile(instance.path, "r") as zip_instance:
        batch = BatchUpload.objects.create(
            batch_type="Archive",
            name=instance.name,
            documents_count=len(zip_instance.namelist()),
            owner=request.user)
    try:
        with zipfile.ZipFile(instance.path, "r") as archive:
            for file_in_archive in archive.namelist():
                with archive.open(file_in_archive, 'r', pwd=str(password)) as f:
                    document_to_analyze(f, file_in_archive, user=request.user, source="local", batch=batch)
                to_massage['uploaded_doc'].append({'document': str(file_in_archive)})
        instance.password = password
    except RuntimeError:
        batch.delete()
        return HttpResponse(json.dumps({
            'massage': 'Wrong password',
            'failed': True,
            'archive': str(instance.name),
            'password': password
        }), content_type='application/json')
    NotificationManager.create_user_message(request.user, "Uploaded", to_massage).send()
    return HttpResponse(json.dumps({
        'archive': str(instance.name)
    }), content_type='application/json')