from django.http import HttpResponse


from dreamed_dms.lib import *
from django.views.generic import TemplateView
from dreamed_dms.forms import *
from dreamed_dms.parsers import carelink_personal, carelink_pro, diasend, gocap, diabetesm, doctor_recommendation_parser,glooko_multi_patient
from dreamed_dms.parsers.tidepool_parser import TidepoolParser
from dreamed_dms.parsers.libre_parser import LibreParser
from dreamed_dms.parsers.ads_mongodb import *
from dreamed_dms.parsers import master_file
from dreamed_dms.decorators import *
from django.utils.decorators import method_decorator
from datetime import datetime as dt, timedelta as td
import json
import time
from dreamed_dms.models import *
from django.shortcuts import render
from django.views.generic.edit import FormView
from adp_api.models import AdpRequest
from dreamed_dms.parsers.lib import find_sync_timestamps
from adp_api.core.lib import process_adp_request,parse_glooko_data,AdpInput

log = logging.getLogger(__name__)

#@method_decorator(staff_member_required, name='dispatch')



class RunAdvisorPro(FormView):
    """
    A view to run the Advisor Pro algorithm on a patient data in the DB and receive the recommendation with an option to feedback directly in the returned page

    - SRS-24
    """
    form_class = RunAdvisorProForm
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form = self.get_form(self.form_class)

        if form.is_valid():
            patient = Patient.objects.get(id=request.POST.get("patient"))

            end_date_str = request.POST.get("end_date")

            if end_date_str:
                end_date = dt.strptime(end_date_str, "%Y-%m-%d")
                end = dt.combine(end_date.date(), dt.max.time())
            else:
                end = dt.combine(dt.now().date(), dt.max.time())

            start_exact = end - td(days=21)
            start = dt.combine(start_exact.date(), dt.min.time())

            language = request.POST.get("language") or patient.language
            adp_request = AdpRequest.objects.create(patient=patient, start=start, end=end, user=request.user, status="IN_PROCESS")  # to avoid running in using the queue
            try:
                process_adp_request(adp_request)
            except Exception as e:
                log.exception(e)
                adp_request.status = "ERROR"
                adp_request.error = "error processing request: " + str(e)
                adp_request.save()

            if adp_request.status == "COMPLETED":
                context = create_recommendation_context(adp_request, language)
                return render(request, 'advisor_pro_output.html', context)
            else:
                log.error("Advisor Pro request Failed: " + str(adp_request.error))
                return HttpResponse("Advisor Pro request Failed: " + str(adp_request.error))
        else:
            return self.form_invalid(form)



class GenerateAdpInput(FormView):
    """
    A view for generating an ADP Input JSON the same way it is generated for an Advisor Pro request

    - SRS-29
    """
    form_class = GenerateAdpInput
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form = self.get_form(self.form_class)

        if form.is_valid():
            patient = Patient.objects.get(id=request.POST.get("patient"))
            # glooko_format = request.POST.get("glooko_format")
            end_date_str = request.POST.get("end_date")

            if end_date_str:
                end_date = dt.strptime(end_date_str, "%Y-%m-%d")
                end = dt.combine(end_date.date(), dt.max.time())
            else:
                end = dt.combine(dt.now().date(), dt.max.time())

            start_exact = end - td(days=21)
            start = dt.combine(start_exact.date(), dt.min.time())

            try:
                adp_input = AdpInput(patient=patient, start=start, end=end)
            except AssertionError as e:
                log.exception(e)
                return HttpResponse("error generating ADP Input JSON: " + str(e))

            # if glooko_format:
            #     return HttpResponse('<textarea rows="50" cols="200">' + json.dumps(adp_input_to_glooko(adp_input), sort_keys=True, indent=4) + '</textarea>')
            # else:
            return HttpResponse('<textarea rows="50" cols="200">'+json.dumps(adp_input.json,sort_keys=True, indent=4)+'</textarea>')
        else:
            return self.form_invalid(form)


class ParsePlans(FormView):
    form_class = ParsePlansForm
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form = self.get_form(self.form_class)

        if form.is_valid():
            patient = Patient.objects.get(id=request.POST.get("patient"))
            plans = json.loads(request.POST.get("plans_json"))

            effective_date_str = request.POST.get("effective_date")

            if not effective_date_str:
                effective_date = dt.now()
            else:
                effective_date = dt.strptime(effective_date_str, "%Y-%m-%d")

            #new plans
            pump_setting, created = patient.pump_settings.get_or_create(start=effective_date, type="ai")
            pump_setting.plan = plans['ai']
            pump_setting.save()

            pump_setting, created = patient.pump_settings.get_or_create(start=effective_date, type="basal")
            pump_setting.plan = plans['basal']
            pump_setting.save()

            pump_setting, created = patient.pump_settings.get_or_create(start=effective_date, type="cr")
            pump_setting.plan = plans['cr']
            pump_setting.save()

            pump_setting, created = patient.pump_settings.get_or_create(start=effective_date, type="cf")
            pump_setting.plan = plans['cf']
            pump_setting.save()

            pump_setting, created = patient.pump_settings.get_or_create(start=effective_date, type="targets")
            pump_setting.plan = plans['targets']
            pump_setting.save()

            #old plans
            plan, created = patient.plans.get_or_create(start_hour=plans['ai']['start_hour'], type="ai", plan_index=1)
            plan.value = plans['ai']['value']
            plan.timestamp = effective_date
            plan.save()

            for x in plans['basal']:
                plan, created = patient.plans.get_or_create(start_hour=x['start_hour'], type="basal", plan_index=1)
                plan.value = x['value']
                plan.timestamp = effective_date
                plan.save()

            for x in plans['cr']:
                plan, created = patient.plans.get_or_create(start_hour=x['start_hour'], type="cr", plan_index=1)
                plan.value = x['value']
                plan.timestamp = effective_date
                plan.save()

            for x in plans['cf']:
                plan, created = patient.plans.get_or_create(start_hour=x['start_hour'], type="cf", plan_index=1)
                plan.value = x['value']
                plan.timestamp = effective_date
                plan.save()

            for x in plans['targets']:
                plan, created = patient.plans.get_or_create(start_hour=x['start_hour'], type="targets", plan_index=1)

                plan.high = x['high'] if x['high'] != "null" else None
                plan.low = x['low'] if x['low'] != "null" else None
                plan.target = x['target'] if x['target'] != "null" else None
                plan.threshold = x['threshold'] if x['threshold'] != "null" else None
                plan.timestamp = effective_date
                plan.save()

            return self.form_valid(form)

        else:
            return self.form_invalid(form)
class ParseLibreReport(FormView):
    """
    A view that enables parsing data to the DB from a Abott Libre report

    - SRS-48
    """
    form_class = ParseLibreReportForm
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form_class = self.get_form_class()
        form = self.get_form(form_class)
        request_files = request.FILES.getlist('reports')

        is_sensor_mode = not request.POST.get("parse_as_bg")
        trial = Trial.objects.get(id=request.POST.get("trial"))
        if form.is_valid():
            files_on_disk = write_files_to_disk(request_files)
            for file in files_on_disk:
                try:
                    libre_parser = LibreParser(trial=trial, is_sensor_mode=is_sensor_mode)
                    with open(file) as f:
                        libre_parser.parse(f)

                except Exception as e:
                    log.exception(e)
                    return HttpResponse("Error:" + str(e) + ". in file: " + str(file))
            return HttpResponse('File Parsed Successfully!')
        else:
            return self.form_invalid(form)



class ParseGlookoAndRunAdvisorPro(FormView):
    """
    A view that enables parsing data to the DB of a glooko patient in a given time and, optionally, run the advisor pro algorithm oin the data fetched

    - SRS-45
    """
    form_class = ParseGlookoForm
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form = self.get_form(self.form_class)

        if form.is_valid():
            # if not request.user.dms:
            #     return HttpResponse("error: configuration error for user" + request.user.email, status=400)
            #
            # if request.user.dms.name not in list(adp_api_settings.dms_settings.keys()):
            #     return HttpResponse("error: configuration error dms " + request.user.dms.name, status=400)

            treatment_plan_request = json.loads(request.POST.get("treatment_plan_request"))
            run_advisor_pro = request.POST.get("run_advisor_pro")

            if not request.user.dms:
                dms = Dms.objects.get(name="glooko")
            else:
                dms = request.user.dms

            trial = Trial.objects.get(id = request.POST.get("trial"))
            patient, created = Patient.objects.get_or_create(trial=trial, ext_name=treatment_plan_request['userId'])

            if "syncTimestamps" in treatment_plan_request:
                params = treatment_plan_request['syncTimestamps']

            else:
                end_date_str = request.POST.get("end_date")

                if not end_date_str:
                    end = dt.combine(dt.now().date(), dt.max.time())
                else:
                    end_date = dt.strptime(end_date_str, "%Y-%m-%d")
                    end = dt.combine(end_date.date(), dt.max.time())

                try:
                    params = find_sync_timestamps(dms=dms, end_date=end,start_date = end-td(days=10), glooko_code=patient.ext_name,last_only=True)
                    log.info("found sync timestamps: "+str(params))
                except Exception as e:
                    log.exception(e)
                    return HttpResponse("error finding sync timestamps: " + str(e))

                #re-calc the time range according to the found syc timestamps
            timestamps = []

            if "meter" in params:
                if params['meter']:
                    meter_ts = dt.strptime(params['meter'], "%Y-%m-%dT%H:%M:%S.%fZ")
                    timestamps.append(meter_ts)
            if "pump" in params:
                if params['pump']:
                    pump_ts = dt.strptime(params['pump'], "%Y-%m-%dT%H:%M:%S.%fZ")
                    timestamps.append(pump_ts)
            if "cgm" in params:
                if params['cgm']:
                    cgm_ts = dt.strptime(params['cgm'], "%Y-%m-%dT%H:%M:%S.%fZ")
                    timestamps.append(cgm_ts)

            if not timestamps:
                error = "no sync timestamps were found"
                log.error(error)
                return HttpResponse(error)

            end = max(timestamps)
            start_exact = min(timestamps) - td(days=21)
            start = dt.combine(start_exact.date(), dt.min.time())

            try:
                parse_glooko_data(patient=patient, dms=dms, sync_timestamps=params)
            except Exception as e:
                error = "data query error: " + str(e)
                log.exception(e)
                return HttpResponse(error)

            if run_advisor_pro:
                #TODO glooko parser should handle optionals params
                language = request.POST.get("language") or patient.language
                adp_request = AdpRequest.objects.create(patient=patient, params=params, start=start, end=end, user=request.user, status="IN_PROCESS")  # to avoid running in using the queue

                try:
                    process_adp_request(adp_request)
                except Exception as e:
                    log.exception(e)
                    adp_request.status = "ERROR"
                    adp_request.error = "error processing request: " + str(e)
                    adp_request.save()

                if adp_request.status == "COMPLETED":
                    context = create_recommendation_context(adp_request, language)
                    return render(request, 'recommendation_doctor.html', context)
                else:
                    return HttpResponse("adp request processing failed: " + str(adp_request.error))

            else:
                return HttpResponse("Done parsing data to DB")

        else:
            return self.form_invalid(form)


class DisplayRecommendation(FormView):
    """
    A view for displaying an Advisor Pro recommendation that was already generated

    - SRS-45
    """
    form_class = DisplayRecommendationForm
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):

        form = self.get_form(self.form_class)

        if form.is_valid():
            adp_request = AdpRequest.objects.get(id=request.POST.get("adp_request"))
            language = request.POST.get("language") or adp_request.patient.language

            context = create_recommendation_context(adp_request, language)
            return render(request, 'advisor_pro_output.html', context)
        else:
            return self.form_invalid(form)


class DisplayRecommendationDoctor(FormView):
    """
    A view for displaying an Advisor Pro recommendation that was already generated and ment to be exported to excel for a doctor review and feedback

    - SRS-45
    """
    form_class = DisplayRecommendationFormDoctor
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):

        form = self.get_form(self.form_class)

        if form.is_valid():
            adp_request = AdpRequest.objects.get(id=request.POST.get("adp_request"))
            language = request.POST.get("language") or adp_request.patient.language

            context = create_recommendation_context(adp_request, language)
            return render(request, 'recommendation_doctor.html', context)
        else:
            return self.form_invalid(form)


def create_recommendation_context_from_feedback(adp_feedback):
    def calc_daily_amount(items):
        sum = (dt.strptime(items[0]['start'], '%H:%M:%S') + td(hours=24) - dt.strptime(items[-1]['start'], '%H:%M:%S')).total_seconds() * items[-1]['value']
        for i, item in enumerate(items[:-1]):
            second = dt.strptime(items[i + 1]['start'], '%H:%M:%S')
            first = dt.strptime(item['start'], '%H:%M:%S')
            duration = second - first
            sum += item['value'] * duration.total_seconds()
        return round(sum / 60 / 60,3)

    data = adp_feedback.data

    context = {}
    context["start_date"] = adp_feedback.request.start.date().strftime("%b. %d, %Y")
    context["end_date"] = adp_feedback.request.end.date().strftime("%b. %d, %Y")
    context['patient_id'] = adp_feedback.request.patient.ext_name

    context['recommended_basal_rates'] = data['plans']['basal']
    context['recommended_total_basal'] = calc_daily_amount(data['plans']['basal'])

    context['recommended_carb_ratio'] = data['plans']['cr']
    context['recommended_correction_factor'] = data['plans']['cf']

    context['recommendation_texts'] = data['rationales']
    context['comment'] = adp_feedback.comment

    context['language_rtl'] = data['meta']['is_rtl']

    context['report_date'] = adp_feedback.received_at
    context['advisor_version'] = adp_feedback.request.recommendation['advisorVersion']
    context['request_id'] = adp_feedback.request.identifier
    return context


class DisplayRecommendationPatient(FormView):
    """
    A view for displaying a doctor feedback for an Advisor Pro recommendation as a recommendation for his patient

    - SRS-45
    """
    form_class = DisplayRecommendationFormPatient
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):

        form = self.get_form(self.form_class)

        if form.is_valid():
            adp_feedback = AdpFeedback.objects.get(id=request.POST.get("adp_feedback"))
            #language = request.POST.get("language") or adp_request.patient.language
            context = create_recommendation_context_from_feedback(adp_feedback)
            return render(request, 'recommendation_patient.html', context)
        else:
            return self.form_invalid(form)


@method_decorator(user_is_admin, name='dispatch')
class CobelliUploader(FormView):
    """
    A view for uploading a diasend report, and parsing it using the diasend parser into the database.

    - SRS-41
    """
    form_class = UploadCobelli
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        from dreamed_dms.parsers import cobelli
        form_class = self.get_form_class()
        form = self.get_form(form_class)
        request_files = request.FILES.getlist('reports')

        if form.is_valid():
            trial = Trial.objects.get(id=request.POST.get("trial"))
            files_on_disk = write_files_to_disk(request_files)

            for file in files_on_disk:
                try:
                    with open(file) as f:
                        data = json.load(f)
                    cobelli.parse(data=data, trial=trial)
                except Exception as e:
                    log.exception(e)
                    return HttpResponse("Error:" + str(e) + ". in file: " + str(file))

            return self.form_valid(form)
        else:
            return self.form_invalid(form)


@method_decorator(user_is_admin, name='dispatch')
class DiasendUploader(FormView):
    """
    A view for uploading a diasend report, and parsing it using the diasend parser into the database.

    - SRS-19
    """
    form_class = UploadDiasend
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form_class = self.get_form_class()
        form = self.get_form(form_class)
        request_files = request.FILES.getlist('reports')
        glucose_only = request.POST.get("glucose_only")

        if form.is_valid():
            trial = Trial.objects.get(id=request.POST.get("trial"))
            files_on_disk = write_files_to_disk(request_files)

            for file in files_on_disk:
                try:
                    diasend.parse(file=file, trial=trial,glucose_only=glucose_only)
                except Exception as e:
                    log.exception(e)
                    return HttpResponse("Error:" + str(e) + ". in file: " + str(file))

            return self.form_valid(form)
        else:
            return self.form_invalid(form)

@method_decorator(user_is_admin, name='dispatch')
class DiabetesmUploader(FormView):
    """
    A view for uploading and parsing a diabetesm report of a patient into the DB

    - SRS-27
    """
    form_class = UploadDiabetesm
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form_class = self.get_form_class()
        form = self.get_form(form_class)
        request_files = request.FILES.getlist('reports')

        if form.is_valid():

            files_on_disk = write_files_to_disk(request_files)
            for file in files_on_disk:
                try:
                    diabetesm.parse(file, trial=Trial.objects.get(id=request.POST.get("trial")), date_format=request.POST.get("date_format"))
                except Exception as e:
                    log.exception(e)
                    return HttpResponse("Error:" + str(e) + ". in file: " + str(file))
            return self.form_valid(form)
        else:
            return self.form_invalid(form)


@method_decorator(user_is_admin, name='dispatch')
class CarelinkProUploader(FormView):
    """
    A view for uploading a carelink pro report, and parsing it using the carelink pro parser into the database.

    - SRS-29
    """
    form_class = UploadCarelink
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form_class = self.get_form_class()
        form = self.get_form(form_class)
        request_files = request.FILES.getlist('reports')

        if form.is_valid():
            files_on_disk = write_files_to_disk(request_files)
            for file in files_on_disk:
                try:
                    carelink_pro.parse(file, trial=Trial.objects.get(id=request.POST.get("trial")), date_format=request.POST.get("date_format"))
                except Exception as e:
                    log.exception(e)
                    return HttpResponse("Error:" + str(e) + ". in file: " + str(file))
            return self.form_valid(form)
        else:
            return self.form_invalid(form)


@method_decorator(user_is_admin, name='dispatch')
class CarelinkPersonalUploader(FormView):
    """
    A view for uploading a carelink personal report, and parsing it using the carelink personal parser into the database.

    - SRS-20
    """
    form_class = UploadCarelinkClinical
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form_class = self.get_form_class()
        form = self.get_form(form_class)
        request_files = request.FILES.getlist('reports')

        if form.is_valid():

            files_on_disk = write_files_to_disk(request_files)
            trial = Trial.objects.get(id=request.POST.get("trial"))
            for file in files_on_disk:
                try:
                    carelink_personal.parse(file, trial=trial, date_format=request.POST.get("date_format"))
                except Exception as e:
                    log.exception(e)
                    return HttpResponse("Error:" + str(e) + ". in file: " + str(file))
            return self.form_valid(form)
        else:
            return self.form_invalid(form)


@method_decorator(user_is_admin, name='dispatch')
class MasterFileUploader(FormView):
    """
    A view for uploading a master file report and parsing it using the master file parser into the database.

    - SRS-21
    """
    form_class = UploadMasterFile
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form_class = self.get_form_class()
        form = self.get_form(form_class)
        request_files = request.FILES.getlist('reports')

        if form.is_valid():
            files_on_disk = write_files_to_disk(request_files)
            for file in files_on_disk:
                try:
                    master_file.parse(file)
                except Exception as e:
                    log.error("Error:" + str(e))
                    return HttpResponse("Error:" + str(e) + ". in file: " + str(file))

            return self.form_valid(form)
        else:
            return self.form_invalid(form)

class GlookoMultiPatient(FormView):
    """
    A view for uploading a master file report and parsing it using the master file parser into the database.

    - SRS-21
    """
    form_class = GlookoMultiPatientForm
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form = self.get_form(self.form_class)

        if form.is_valid():
            end_date_str = request.POST.get("end_date")
            if end_date_str:
                end_date = dt.strptime(end_date_str, "%Y-%m-%d")
                end = dt.combine(end_date.date(), dt.max.time())
            else:
                end = None

            start_date_str = request.POST.get("start_date")
            if start_date_str:
                start_date = dt.strptime(start_date_str, "%Y-%m-%d")
                start = dt.combine(start_date.date(), dt.min.time())
            else:
                start = None

            if start and end:
                if end < start:
                    return HttpResponse("start date cannot be greater then end date")

            dms = Dms.objects.get(id=request.POST.get("dms"))

            request_files = request.FILES.getlist('reports')
            files_on_disk = write_files_to_disk(request_files)
            for file in files_on_disk:
                try:
                    glooko_multi_patient.parse(file=file,dms=dms,end_date=end,start_date=start)
                except Exception as e:
                    log.exception("Error:" + str(e))
                    return HttpResponse("Error:" + str(e) + ". in file: " + str(file))

            return self.form_valid(form)
        else:
            return self.form_invalid(form)


@method_decorator(user_is_admin, name='dispatch')
class DoctorRecommendationUploader(FormView):
    """
    A view for uploading a master file report and parsing it using the master file parser into the database.

    - SRS-45
    """
    form_class = UploadDoctorRecoForm
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form_class = self.get_form_class()
        form = self.get_form(form_class)
        request_files = request.FILES.getlist('reports')

        if form.is_valid():
            files_on_disk = write_files_to_disk(request_files)
            for file in files_on_disk:
                try:
                    doctor_recommendation_parser.parse(file)
                except Exception as e:
                    log.exception("Error:" + str(e))
                    return HttpResponse("Error:" + str(e) + ". in file: " + str(file))

            return self.form_valid(form)
        else:
            return self.form_invalid(form)


class upload_done(TemplateView):
    """
    A view for displaying a done message for general use cases only needed a "done" response for a user.
    """
    template_name = "done.html"


@method_decorator(user_can_login_app, name='dispatch')
class Index(TemplateView):
    """
    A view for the main app page.
    """
    template_name = "index.html"


@method_decorator(user_is_admin, name='dispatch')
class GocapSync(FormView):
    """
    A view for pooling a Gocap user using the Gocap api and parse it to the database using the gocap parser.
    """
    form_class = GocapForm
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def get_form_kwargs(self):
        kw = super(GocapSync, self).get_form_kwargs()
        kw['request'] = self.request  # the trick!
        return kw

    def post(self, request, **kwargs):
        form = self.get_form(self.form_class)

        if form.is_valid():
            gocap_user = request.POST.get('gocap_user')
            gocap_password = request.POST.get('gocap_password')
            patient = Patient.objects.get(id=request.POST.get("patient"))
            # login:
            try:
                gocap.get_data(gocap_user, gocap_password, patient)
            except Exception as e:
                log.error("Error:" + str(e))
                return HttpResponse("Error:" + str(e))

            return self.form_valid(form)
        else:
            return self.form_invalid(form)


@user_is_admin
def pull_data(request):
    log.debug("||" + str(dt.now()) + "|| " + "Before Getting into Parser")
    req_counter = parse_mongo_data()
    return HttpResponse('Finished Successfully \n  (%d)  Requests Parsed Successfully ' % req_counter)


@method_decorator(user_is_admin, name='dispatch')
class TidePoolUploader(FormView):
    """
    A view for uploading a TidePool Data, parsing it using the tidepool parser into the database.

    - SRS-44
    """
    form_class = UploadTidePool
    template_name = 'form_generic.html'  # Replace with your template.
    success_url = 'done/'  # Replace with your URL or reverse().

    def post(self, request, **kwargs):
        form_class = self.get_form_class()
        form = self.get_form(form_class)
        request_files = request.FILES.getlist('reports')

        if form.is_valid():
            files_on_disk = write_files_to_disk(request_files)
            for file in files_on_disk:
                try:
                    tidepool_parser = TidepoolParser()
                    with open(file) as f:
                        tidepool_parser.parse(f)

                except Exception as e:
                    log.exception(e)
                    return HttpResponse("Error:" + str(e) + ". in file: " + str(file))
            return HttpResponse('File Parsed Successfully!')
        else:
            return self.form_invalid(form)