import {ApiResult} from "./ApiResult";
import {BaseRoute} from "../routes/BaseRoute";
import {NextFunction, Request, Response, Router} from "express";
import * as fs from "fs";
import * as formidable from "formidable";

import {AcademicYearRepository, SchoolRepository} from "@rolesvillesoftware/tiberhealthmodel/repositories";
import {ExamContextRepository} from "@rolesvillesoftware/tiberhealthmodel/repositories/ExamContextRepository";

import {Exam} from "@rolesvillesoftware/tiberhealthmodel/dto";

import {Importer} from "../../importer/Importer";
import {Parser} from "../../parser/Parser";
import {ExamResultSummary} from "../../models/concretes/ExamResultSummary";
import {ExamResultSummaryParser} from "../../models/concretes/ExamResultSummaryParser";
import {ExamList} from "@rolesvillesoftware/tiberhealthmodel/contexts/exam/ExamList";
import {SafePromise} from "@rolesvillesoftware/tools/dist";

export class ExamApi extends BaseRoute<ExamApi> {
    get concrete(): ExamApi {
        return this;
    }

    static createRoute(router: Router) {
        console.log("[IndexRoute::create] Creating Exam API.");

        router.get("/exam",
            (req: Request, res: Response, next: NextFunction) => {
                new ExamApi(req, res, next).checkAuth(controller => controller.get());
            });

        router.get("/examList",
            (req: Request, res: Response, next: NextFunction) => {
                new ExamApi(req, res, next).checkAuth(controller => controller.examList(req, res, next));
            });

        router.post("/exam",
            (req: Request, res: Response, next: NextFunction) => {
                new ExamApi(req, res, next).checkAuth(controller => controller.upload(req, res, next));
            });


    }

    private deleteFile(path: string) {
        try {
            fs.unlinkSync(path);
        } catch (e) {
        }
    }

    private get() {
        this.res.write("peter pan");
        this.res.end();
    }

    private upload(req, res, next) {
        const apiResult = new ApiResult(res);

        let warehouseConnection = this.warehouseConnection;
        let form = new formidable.IncomingForm();
        form.uploadDir = "./files";
        form.keepExtensions = true;
        form.parse(this.req, (err, fields, files) => {
            Promise.all([
                new SchoolRepository(warehouseConnection).getById(parseInt(fields.school as string)),
                new AcademicYearRepository(warehouseConnection).getById(parseInt(fields.academicPeriod as string))
            ])
                .then(data => {
                    const school = data[0];
                    const period = data[1];

                    let exam = new Exam(fields.examName as string, period)
                        .getOrCreate(warehouseConnection)
                        .then(item => {
                            item.dateUploaded = new Date();
                            let file = fs.readFileSync(files.file.path, {encoding: "utf-8", flag: "r"});
                            new Importer(warehouseConnection,
                                ExamResultSummary,
                                Parser,
                                null,
                                new ExamResultSummaryParser(warehouseConnection, item, school))
                                .importContents(file)
                                .then(result => {
                                    apiResult.setSuccess(null, "Import Loaded");
                                    this.deleteFile(files.file.path);
                                })
                                .catch(error => {
                                    apiResult.setError(error);
                                    this.deleteFile(files.file.path);
                                });
                        })
                        .catch(error => {
                            apiResult.setError(error);
                            this.deleteFile(files.file.path);
                        });
                })
                .catch(error => {
                    apiResult.setError(error);
                    this.deleteFile(files.file.path);
                });
        });
    }

    private examList(req, res, next) {
        const apiResult = new ApiResult(res);
        SafePromise.run(() => new ExamContextRepository(this.contextConnection).getExamList())
            .then(
                data => {
                    if (data.isError) {
                        apiResult.setError(data.error);
                    }
                    else {
                        try {
                            apiResult.setSuccess((data.value as ExamList[]).map(item => item.cloneForJson()));
                        } catch (error) {
                            apiResult.setError(error);
                        }
                    }
                }
            )
            .catch(error => apiResult.setError(error));
    }
}