# -*- coding: utf-8 -*-
import signal

from flask import Flask, request, jsonify, json
from flask_sqlalchemy import SQLAlchemy
from flask_restful import Resource, Api
import Training as pdm_train
import Utils
from OnlinePrediction import OnlinePrediction
import os
from flask_cors import CORS
from multiprocessing import Process
import threading
import queue
import logging
import logging.config
import yaml

MYDIR = os.path.dirname(os.path.realpath(__file__))
LOGGING_CONF_FILE = os.path.join(MYDIR, "logging.yml")


def read_log_conf(yaml_file):
    with open(yaml_file) as f:
        logging.config.dictConfig(yaml.safe_load(f))

# temporarily added for the demo video
your_rest_server_port = 5000

# We use a Thread to join a subprocess for two reasons:
# 1) If a subprocess is not joined is considered as a zombie hence it cannot be stopped
# 2) If the parent process joins the sub-process then the execution is freezed waiting for the sub-process to return/exit.
# Hence, we use a Thread to join in order to avoid zombie process creation and to allow the parent process to continue its
# execution.
class Joiner(threading.Thread):
    def __init__(self, q):
        threading.Thread.__init__(self)
        self.__q = q

    def run(self):
        while True:
            child = self.__q.get()
            print(child)
            if child == None:
                return
            child.join()


# stores the Pids of the running processes
q = queue.Queue()
running_prediction_processes = []
params = {}

app = Flask(__name__)

read_log_conf(LOGGING_CONF_FILE)
app.logger = logging.getLogger("mltd-api")
app.logger.info("MLTD API is running")

# Cross-Origin Resource Sharing (CORS) - accept all origins - needed in order to communicate with the web interface
cors = CORS(app, resources={"/*": {"origins": "*"}})
api = Api(app)

# these details are used for the SQLite connection and handling
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~SQLite~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
basedir = os.path.abspath(os.path.dirname(__file__))
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///" + os.path.join(
    basedir, "pdm.sqlite"
)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)


class Model(db.Model):
    __tablename__ = "models"
    __table_args__ = {"extend_existing": True}
    model_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    description = db.Column(db.String(1000))
    timedb_host = db.Column(db.String(180))
    timedb_port = db.Column(db.String(5))
    timedb_username = db.Column(db.String(180))
    timedb_password = db.Column(db.String(180))
    timedb_ssl = db.Column(db.String(180))
    timedb_dbname = db.Column(db.String(80))
    asset_id = db.Column(db.String(300))
    timedb_adt_table = db.Column(db.String(300))
    timedb_xlsiem_table = db.Column(db.String(300))
    timedb_od_table = db.Column(db.String(300))
    mp_thres_X = db.Column(db.Integer)
    mp_thres_Y = db.Column(db.Integer)
    mp_thres_Z = db.Column(db.Integer)
    mp_pat_length = db.Column(db.Integer)
    rf_s = db.Column(db.Float)
    rf_midpoint = db.Column(db.String(5))
    hours_before = db.Column(db.String(5))
    time_segments = db.Column(db.String(5))
    incidents = db.relationship(
        "Failure_Incidents",
        backref="models",
        cascade="all, delete-orphan",
        lazy="joined",
    )

    def __init__(
        self,
        description,
        timedb_host,
        timedb_port,
        timedb_username,
        timedb_password,
        timedb_ssl,
        timedb_dbname,
        asset_id,
        timedb_adt_table,
        timedb_xlsiem_table,
        timedb_od_table,
        mp_thres_X,
        mp_thres_Y,
        mp_thres_Z,
        mp_pat_length,
        rf_s,
        rf_midpoint,
        hours_before,
        time_segments,
    ):
        self.description = description
        self.timedb_host = timedb_host
        self.timedb_port = timedb_port
        self.timedb_username = timedb_username
        self.timedb_password = timedb_password
        self.timedb_ssl = timedb_ssl
        self.timedb_dbname = timedb_dbname
        self.asset_id = asset_id
        self.timedb_adt_table = timedb_adt_table
        self.timedb_xlsiem_table = timedb_xlsiem_table
        self.timedb_od_table = timedb_od_table
        self.mp_thres_X = mp_thres_X
        self.mp_thres_Y = mp_thres_Y
        self.mp_thres_Z = mp_thres_Z
        self.mp_pat_length = mp_pat_length
        self.rf_s = rf_s
        self.rf_midpoint = rf_midpoint
        self.hours_before = hours_before
        self.time_segments = time_segments

    def toString(self):
        fed = "["  # failure_event_dates
        for incident in self.incidents:
            fed += '"' + incident.date + '"'
            fed += ","
        if len(fed) > 1:
            fed = fed[: (len(fed) - 1)]
        fed += "]"
        return (
            '{"model_id":"'
            + str(self.model_id)
            + '","description":"'
            + self.description
            + '","timedb_host":"'
            + self.timedb_host
            + '","timedb_port":"'
            + self.timedb_port
            + '","timedb_username":"'
            + self.timedb_username
            + '","timedb_password":"'
            + self.timedb_password
            + '","timedb_ssl":"'
            + self.timedb_ssl
            + '","timedb_dbname":"'
            + self.timedb_dbname
            + '","asset_id":"'
            + self.asset_id
            + '","timedb_adt_table":"'
            + self.timedb_adt_table
            + '","timedb_xlsiem_table":"'
            + self.timedb_xlsiem_table
            + '","timedb_od_table":"'
            + self.timedb_od_table
            + '","mp_thres_X":'
            + str(self.mp_thres_X)
            + ',"mp_thres_Y":'
            + str(self.mp_thres_Y)
            + ',"mp_thres_Z":'
            + str(self.mp_thres_Z)
            + ',"rf_s":'
            + str(self.rf_s)
            + ',"rf_midpoint":'
            + str(self.rf_midpoint)
            + ',"hours_before":'
            + str(self.hours_before)
            + ',"time_segments":"'
            + str(self.time_segments)
            + '","incidents":'
            + fed
            + "}"
        )

    def toJSON(self):
        return json.loads(self.toString())


class Failure_Incidents(db.Model):
    __tablename__ = "dates"
    __table_args__ = {"extend_existing": True}
    date_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    model_id = db.Column(db.Integer, db.ForeignKey("models.model_id"), nullable=False)
    date = db.Column(db.String(24))

    def __init__(self, model_id, date):
        self.model_id = model_id
        self.date = date


db.create_all()

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~end of SQLite~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Training API Endopoints~~~~~~~~~~~~~~~~~~~~~~~~~~~~#

# endpoint to create new model
@app.route("/api/v1.0/mltd/training", methods=["POST"])
def add_model():
    description = request.json["description"]
    timedb_host = request.json["timedb_host"]
    timedb_port = request.json["timedb_port"]
    timedb_username = request.json["timedb_username"]
    timedb_password = request.json["timedb_password"]
    timedb_ssl = request.json["timedb_ssl"]
    timedb_dbname = request.json["timedb_dbname"]
    asset_id = request.json["asset_id"]
    timedb_adt_table = request.json["timedb_adt_table"]
    timedb_xlsiem_table = request.json["timedb_xlsiem_table"]
    timedb_od_table = request.json["timedb_od_table"]
    mp_thres_X = request.json["mp_thres_X"]
    mp_thres_Y = request.json["mp_thres_Y"]
    mp_thres_Z = request.json["mp_thres_Z"]
    mp_pat_length = request.json["mp_pat_length"]
    rf_s = request.json["rf_s"]
    rf_midpoint = request.json["rf_midpoint"]
    hours_before = request.json["hours_before"]
    time_segments = request.json["time_segments"]
    dates = request.json["dates"]
    rre = bool(request.json["rre"])
    rfe = bool(request.json["rfe"])
    kofe = bool(request.json["kofe"])
    mil_over = bool(request.json["mil_over"])
    fs = bool(request.json["fs"])


    new_model = Model(
        description,
        timedb_host,
        timedb_port,
        timedb_username,
        timedb_password,
        timedb_ssl,
        timedb_dbname,
        asset_id,
        timedb_adt_table,
        timedb_xlsiem_table,
        timedb_od_table,
        mp_thres_X,
        mp_thres_Y,
        mp_thres_Z,
        mp_pat_length,
        rf_s,
        rf_midpoint,
        hours_before,
        time_segments,
    )
    db.session.add(new_model)
    db.session.commit()

    for date in dates:
        date = Failure_Incidents(model_id=new_model.model_id, date=date)
        db.session.add(date)
    db.session.commit()
    app.logger.info("MLTD Training is triggered")
    proc = Process(
        target=pdm_train.do_the_training,
        args=(
            new_model.model_id,
            timedb_host,
            timedb_port,
            timedb_username,
            timedb_password,
            timedb_ssl,
            timedb_dbname,
            asset_id,
            timedb_adt_table,
            timedb_xlsiem_table,
            timedb_od_table,
            mp_thres_X,
            mp_thres_Y,
            mp_thres_Z,
            mp_pat_length,
            rf_s,
            rf_midpoint,
            hours_before,
            time_segments,
            dates,
            False,
            rre,
            rfe,
            kofe,
            mil_over,
            fs,
        ),
    )
    proc.start()
    print(proc.pid)
    q.put(proc)
    j = Joiner(q)
    j.start()

    return jsonify({"model_id": new_model.model_id, "process_id": proc.pid})


# endpoint to check whether the training process is still runinng
@app.route("/api/v1.0/mltd/training/status/<int:pid>", methods=["GET"])
def is_running(pid):
    return jsonify({"is_running": check_pid(pid)})

def check_pid(pid):
    """ Check For the existence of a unix pid. """
    try:
        os.kill(pid, 0)
    except OSError:
        return False
    else:
        return True

# endpoint to show all models
@app.route("/api/v1.0/mltd/training", methods=["GET"])
def get_model():
    all_models_list = "["
    all_models = Model.query.all()
    for model in all_models:
        all_models_list += model.toString()
        all_models_list += ","
    if len(all_models_list) > 1:
        all_models_list = all_models_list[: (len(all_models_list) - 1)]
    all_models_list += "]"
    print(all_models_list)
    return jsonify(json.loads(all_models_list))


# endpoint to get model detail by id
@app.route("/api/v1.0/mltd/training/<id>", methods=["GET"])
def model_detail(id):
    model = Model.query.get(id)
    print(model.toString())
    return jsonify(model.toJSON())  # model_schema.jsonify(model)


# endpoint to delete model
@app.route("/api/v1.0/mltd/training/<id>", methods=["DELETE"])
def model_delete(id):
    model = Model.query.get(id)
    db.session.delete(model)
    db.session.commit()
    if os.path.exists(os.path.join(basedir, "train_" + str(id) + ".dat")):
        os.remove(os.path.join(basedir, "train_" + str(id) + ".dat"))
    else:
        app.logger.error("The file does not exist")
    return jsonify(model.toJSON())


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~End of Training API Endopoints~~~~~~~~~~~~~~~~~~~~~~~~~~~~#


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Threats Identification API Endopoints~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
# endpoint to start the online prediction process
@app.route("/api/v1.0/mltd/threat-identification/<trainID>/<top>", methods=["GET"])
def obtain_new_threats(trainID, top):
    sql_conn = Utils.create_sqlite_connection("pdm.sqlite")
    time_segments = Utils.select_model_attribute(
        sql_conn, trainID, "time_segments"
    )
    pdm_online = OnlinePrediction()
    (
        pat_length,
        weak_bins_mapping,
        mp,
        dataset_values,
        regr,
        feature_importance,
        artificial_events_generation,
    ) = pdm_online.load_data("train_" + str(trainID) + ".dat")
    imp_events = feature_importance[: int(top)].index.values
    return jsonify({"important_events": str(list(imp_events)),"timeframe":time_segments})


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~End of Threats Identification API Endopoints~~~~~~~~~~~~~~~~~~~~~~~~~~~~#


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Prediction API Endopoints~~~~~~~~~~~~~~~~~~~~~~~~~~~~#

# endpoint to start the online prediction process
@app.route("/api/v1.0/mltd/prediction", methods=["POST"])
def run_prediction():
    # get data from the JSON of the POST request
    model_id = int(request.json["model_id"])
    mqtt_host = request.json["mqtt_host"]
    mqtt_port = int(request.json["mqtt_port"])
    mqtt_topic = request.json["mqtt_topic"]
    prediction_threshold = request.json["prediction_threshold"]
    report_timedb_host = request.json["report_timedb_host"]
    report_timedb_port = request.json["report_timedb_port"]
    report_timedb_username = request.json["report_timedb_username"]
    report_timedb_password = request.json["report_timedb_password"]
    report_timedb_database = request.json["report_timedb_database"]
    report_timedb_table = request.json["report_timedb_table"]
    report_timedb_ssl = request.json["report_timedb_ssl"]
    report_asset_id = request.json["report_asset_id"]
    app.logger.info("MLTD Online is triggered")
    # Start the online monitoring process in a new subprocess
    pdm_online = OnlinePrediction()
    proc = Process(
        target=pdm_online.start_online_prediction_MQTT,
        args=(
            model_id,
            mqtt_host,
            mqtt_port,
            mqtt_topic,
            prediction_threshold,
            report_timedb_host,
            report_timedb_port,
            report_timedb_username,
            report_timedb_password,
            report_timedb_database,
            report_timedb_table,
            report_timedb_ssl,
            report_asset_id,
        ),
    )
    proc.start()

    # Put the Pid (Process id) in a Queue in order to be able to handle it (stop/get status)
    q.put(proc)
    running_prediction_processes.append(proc.pid)
    # Join the new process using a new Thread (see at be beginning of the script why)
    j = Joiner(q)
    j.start()

    # return the process_id
    return jsonify({"process_id": proc.pid})


# endpoint to get the defaults values for the online prediction process
@app.route("/api/v1.0/mltd/prediction/defaults", methods=["GET"])
def get_defaults():
    global params
    if len(params) == 0:
        default_values = {}
        default_values["model_id"] = "1"
        default_values["mqtt_host"] = "mqtt-broker"
        default_values["mqtt_port"] = "1883"
        default_values["mqtt_topic"] = "hot-forming-press/meas"
        default_values["prediction_threshold"] = "0.5"
        default_values["report_dss_host"] = "http://localhost"
        default_values["report_dss_port"] = "9100"
        default_values["report_timedb_host"] = "https://localhost"
        default_values["report_timedb_port"] = "8086"
        default_values["report_timedb_username"] = ""
        default_values["report_timedb_password"] = ""
        default_values["report_timedb_database"] = "Axoom1"
        default_values["report_timedb_table"] = "Predicted_failures"
        default_values["report_timedb_ssl"] = "True"
        return jsonify(default_values)
    else:
        return jsonify(params)


# endpoint to get the defaults values for the online prediction process
@app.route("/api/v1.0/mltd/prediction/saveParams", methods=["POST"])
def save_params():
    global params
    params = request.json
    return jsonify("params saved")


# endpoint to stop a specific online prediction instance
@app.route("/api/v1.0/mltd/prediction/stop/<int:pid>", methods=["GET"])
def stop_prediction(pid):
    if Utils.check_pid(pid):
        os.kill(pid, signal.SIGTERM)
        running_prediction_processes.remove(pid)
    return jsonify("stopped")


# endpoint to get all the online prediction instances
@app.route("/api/v1.0/mltd/prediction/status", methods=["GET"])
def get_running_predictions():
    global running_prediction_processes
    pids = {}
    for pid in running_prediction_processes:
        pids[pid] = "/api/v1.0/mltd/prediction/stop/" + str(pid)
    return jsonify(pids)


# endpoint to check whether the prediction instance is still running
@app.route("/api/v1.0/mltd/prediction/status/<int:pid>", methods=["GET"])
def is_running_prediction(pid):
    return jsonify({"is_running": Utils.check_pid(pid)})


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~End of Prediction API Endopoints~~~~~~~~~~~~~~~~~~~~~~~~~~~~#

if __name__ == "__main__":
    app.run(
        debug=False, host="0.0.0.0"
    )  # open the API to everyone (i.e. host=0.0.0.0 (unsafe)), api accessible from 5000 port