from flask import Flask, jsonify, request
from sklearn.linear_model import LogisticRegression

## additional imports
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.externals import joblib
from sklearn.datasets import load_iris
import numpy as np

import pandas as pd

boosted_model = joblib.load('boosted.pkl')

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'


@app.route('/ian')
def ian():

    from sklearn.datasets import load_iris
    import pandas as pd

    data = load_iris()
    df = pd.DataFrame(data['data'], columns=['sepal_len', 'sepal_width', 'petal_lengh', 'petal_width'])
    y = data['target']

    from sklearn.tree import DecisionTreeClassifier
    model = DecisionTreeClassifier(criterion='gini', random_state=42)

    input_sepal_len = request.args.get("sepal_len")
    input_sepal_width = request.args.get("sepal_width")
    input_petal_lengh = request.args.get("petal_lengh")
    input_petal_width = request.args.get("petal_width")

    if input_sepal_len:
        model.fit(df, y)
        list_of_data_to_fit =  [
            float(input_sepal_len),
            float(input_sepal_width),
            float(input_petal_lengh),
            float(input_petal_width)
        ]

        predicted           =  model.predict(list_of_data_to_fit).tolist()
        probabilities       =  model.predict_proba(list_of_data_to_fit).tolist()

        result = {
            "response": "ok",
            "predictions": predicted,
            "score": model.score(df, y),
            "probabilities": {flower: probabilities[0][index] for index, flower in enumerate(model.classes_.tolist())}
        }

    else:
        return "Please pass an input"

    return jsonify(result)


@app.route('/boosted')
def boosted():

    input_sepal_len = request.args.get("sepal_len")
    input_sepal_width = request.args.get("sepal_width")
    input_petal_lengh = request.args.get("petal_lengh")
    input_petal_width = request.args.get("petal_width")

    if input_sepal_len:

        list_of_data_to_fit =  [
            float(input_sepal_len),
            float(input_sepal_width),
            float(input_petal_lengh),
            float(input_petal_width)
        ]

        predicted           =  boosted_model.predict(list_of_data_to_fit).tolist()
        # probabilities       =  boosted_model.predict_proba(list_of_data_to_fit).tolist()

        result = {
            "response": "ok",
            "predictions": predicted,
            # "score": boosted.score(df, y),
            # "probabilities": {flower: probabilities[0][index] for index, flower in enumerate(boosted.classes_.tolist())}
        }

    else:
        return "Please pass an input"

    return jsonify(result)



@app.route('/predict-iris')
def predict_iris():

    # Load data
    iris = load_iris()

    # print("Loaded iris", iris)

    # Fit our model
    logreg = LogisticRegression()
    model  = logreg.fit(iris['data'], iris['target'])
    model.predict_proba(iris['data'])

    # Parameters from GET request
    sepal_length  = request.args.get("sepal_length")
    sepal_width   = request.args.get("sepal_width")
    petal_length  = request.args.get("petal_length")
    petal_width   = request.args.get("petal_width")

    # To predict
    to_predict = np.array([
        float(sepal_length),
        float(sepal_width),
        float(petal_length),
        float(petal_width)
    ])

    print(
        "My input parameters are:",
        sepal_length, sepal_width,
        petal_length, petal_width
    )

    if all([sepal_length, sepal_width, petal_length, petal_width]):
        result = {
            "message": "OK",
            "predict": model.predict(to_predict).tolist(),
            "probas": model.predict_proba(to_predict).tolist()
        }
    else:
        result = {
            "message": "Please set input!"
        }

    return jsonify(result)



@app.route('/json-test')
def json_test():

    my_data = [
        {"student": "Anthony", "Speed": 23.5, "Power": "over 9000"},
        {"student": "Ruairi", "Speed": 23.55, "Power": "over 9000"},
        {"student": "Sam", "Speed": 23.2255, "Power": "over 9000"},
        {"student": "Evan", "Speed": 23.52553234, "Power": "over 9000"},
    ]

    return jsonify(my_data)

@app.route('/predict-student')
def predict_student():

    print("Something...")

    my_data = [
        {"student": "Anthony", "Speed": 23.5, "Power": "over 9000"},
        {"student": "Ruairi", "Speed": 23.55, "Power": "over 9000"},
        {"student": "Sam", "Speed": 23.2255, "Power": "over 9000"},
        {"student": "Evan", "Speed": 23.52553234, "Power": "over 9000"},
    ]

    df = pd.DataFrame(my_data)

    logreg = LogisticRegression()
    X     = df[['Speed']].values
    model = logreg.fit(X, df["student"].values)
    speed = request.args.get("speed")
    ponzi = request.args.get("ponzi")

    print("Ponzi is: ", ponzi)

    if speed:
        predicted = model.predict([float(speed), "power"]).tolist()
        probabilities = model.predict_proba([float(speed)]).tolist()
        result = {
            "response": "ok",
            "predictions": predicted,
            "probabilities": {student: probabilities[0][index] for index, student in enumerate(model.classes_.tolist())}
        }
    else:
        result = {"response": "not found", "message": "Please provide a data for our model to predict!"}



    return jsonify(result)

if __name__ == '__main__':
    app.run(host = "0.0.0.0")