import os
import shutil

import folium
import pandas as pd
from flask import Flask
from flask import request, render_template
from flask import send_from_directory, url_for, redirect
from werkzeug.utils import secure_filename

from scripts import create_mulog

print("version: 1.5")
ASSETS_DIR = os.path.dirname(os.path.abspath(__file__))
app = Flask(__name__)

# app.config['SECRET_KEY'] = '^%huYtFd90;90jjj'
# app.config['MULOGS'] = 'static'
app.config['MAX_CONTENT_LENGTH'] = 1024 * 1024 * 10  # 10mb
app.config['MAX_RECOMMENDED_POS'] = 10000
app.config['UPLOAD_EXTENSIONS'] = ['.log']
app.config['UPLOAD_PATH'] = 'uploads'
app.config['FILE_NAME'] = app.config['IGN1A'] = None

questions = []
counter_files = 0


@app.route('/', methods=['GET', 'POST'])
@app.route("/home", methods=['GET', 'POST'])
def index():
    environment = request.host
    clear = False
    if request.method == 'POST':
        if len(questions) > 20:
            del questions[:1]
        if request.form['submit_button'] == "Clear":
            del questions[:]
            return render_template('index_v2.html', questions=questions,
                                   environment=environment, clear=True,
                                   lenquestions=len(questions))
        elif request.form['submit_button'] == "Generate":
            if request.form['modes'] == "None":
                questions.append({
                    'loglevel': request.form['loglevels'],
                    'id32': request.form['start-id32'],
                    'number_swmu': request.form['number_of_swmu'],
                    'mode': "None",  # set default run mode
                    'server_host': request.form['server_hosts'],
                    'server_port': request.form['server_ports'],
                    'start_port': request.form['start_ports'],
                    'bt_spontaneous_timeout': request.form[
                        'bt_spontaneous_timeouts'],
                    'sigma': request.form['sigmas'],
                    'sta': request.form['stas'],
                    'sta_pause': request.form['sta_pauses'],
                    'ft_delay': request.form['ft_delays'],
                    'ft_mode': request.form['ft_modes'],
                })
            elif request.form['modes'] == "run":
                questions.append({
                    'loglevel': request.form['loglevels'],
                    'id32': request.form['start-id32'],
                    'number_swmu': request.form[
                        'number_of_swmu'],
                    'mode': request.form['modes'],
                    'server_host': request.form['server_hosts'],
                    'server_port': request.form['server_ports'],
                    'start_port': request.form['start_ports'],
                    'bt_spontaneous_timeout': request.form[
                        'bt_spontaneous_timeouts'],
                    'sigma': request.form['sigmas'],
                    'sta': request.form['stas'],
                    'sta_pause': request.form['sta_pauses'],
                    'ft_delay': request.form['ft_delays'],
                    'ft_mode': request.form['ft_modes'],
                    'latitude': request.form['latitudes'],
                    'longitude': request.form['longitudes'],
                    'domain': request.form['domains'],
                    'near_by_domain': request.form['near_by_domains'],
                    'x01': request.form['x01s'],
                    'x01_pause': request.form['x01_pauses'],
                    'units_wo_x1a': request.form['units_wo_x1as'],
                    'x1a_pause': request.form['x1a_pauses'],
                    'x1a_mask': request.form['x1a_masks'],
                    'x1a_type': request.form['x1a_types'],
                    'x1d': request.form['x1ds'],
                    'x1d_pause': request.form['x1d_pauses'],
                    'x1d_weight_axles': request.form['x1d_weight_axles'],

                })
            elif request.form['modes'] == "sim":
                questions.append({
                    'loglevel': request.form['loglevels'],
                    'id32': request.form['start-id32'],
                    'number_swmu': request.form[
                        'number_of_swmu'],
                    'mode': request.form['modes'],
                    'server_host': request.form['server_hosts'],
                    'server_port': request.form['server_ports'],
                    'start_port': request.form['start_ports'],
                    'bt_spontaneous_timeout': request.form[
                        'bt_spontaneous_timeouts'],
                    'sigma': request.form['sigmas'],
                    'sta': request.form['stas'],
                    'sta_pause': request.form['sta_pauses'],
                    'ft_delay': request.form['ft_delays'],
                    'ft_mode': request.form['ft_modes'],
                    'log': request.form['logs'],
                    'sim_time_check': request.form['sim_time_checks'],
                    'sim_stop': request.form['sim_stops'],
                })
            elif request.form['modes'] == "simfast":
                questions.append({
                    'loglevel': request.form['loglevels'],
                    'id32': request.form['start-id32'],
                    'number_swmu': request.form[
                        'number_of_swmu'],
                    'mode': request.form['modes'],
                    'server_host': request.form['server_hosts'],
                    'server_port': request.form['server_ports'],
                    'start_port': request.form['start_ports'],
                    'bt_spontaneous_timeout': request.form[
                        'bt_spontaneous_timeouts'],
                    'sigma': request.form['sigmas'],
                    'sta': request.form['stas'],
                    'sta_pause': request.form['sta_pauses'],
                    'ft_delay': request.form['ft_delays'],
                    'ft_mode': request.form['ft_modes'],
                    'log': request.form['logs_simfast'],
                    'sim_time_check': request.form['sim_time_checks_simfast'],
                    'sim_stop': request.form['sim_stops'],
                    'simulate_pause': request.form['simulate_pauses'],
                })
    return render_template('index_v2.html', questions=questions,
                           environment=environment, clear=clear,
                           lenquestions=len(questions))


@app.route('/info')
def info():
    environment = request.host
    return render_template('info.html', environment=environment)


@app.route('/helpswmu')
def helpswmu():
    environment = request.host
    return render_template('helpswmu.html', environment=environment)


"""
@app.route('/mulog_read')
def mulog_read():
    environment = request.host
    return render_template('mulog_read.html', environment=environment)
"""


@app.route('/mulog_read')
def upload_file():
    environment = request.host
    #  environment_road = f"http://{environment}/uploader"  # on local
    environment_road = f"https://{environment}/uploader"
    max_pos = app.config['MAX_RECOMMENDED_POS']
    files = listdir_nopos(app.config['UPLOAD_PATH'])
    max_size = (app.config['MAX_CONTENT_LENGTH']) / (1024 * 1024)  # in mb
    ign1a = app.config['IGN1A']
    text = warn = ""
    mulogt = []
    other_type_ttt = []
    pos_file = {'latitude': [], 'longitude': [], "msg_type": []}
    x01 = x04 = x05 = x08 = x09 = x13 = x14 = x25 = x26 = x0b = 0
    x0d = x1a = x1c = x1d = x02 = x10 = x0e = ts_c = pos_c = 0
    if files:
        try:
            mulog_path = f"{app.config['UPLOAD_PATH']}/{files[0]}"
            mulog_data = create_mulog.dir_mulog(
                import_dir=mulog_path, sim_time_check=False)

            # (pos, log, ts_, type, pos)
            for (count, message, old_ts, message_type, message_type_parse,
                 message_type_full_parse, list_ts_warning) in mulog_data:
                warn = list_ts_warning
                if message_type["type"] == b'\x01':
                    x01 += 1
                elif message_type["type"] == b'\x04':
                    x04 += 1
                elif message_type["type"] == b'\x05':
                    x05 += 1
                elif message_type["type"] == b'\x08':
                    x08 += 1
                elif message_type["type"] == b'\x09':
                    x09 += 1
                elif message_type["type"] == b'\x13':
                    x13 += 1
                elif message_type["type"] == b'\x14':
                    x14 += 1
                elif message_type["type"] == b'\x25':
                    x25 += 1
                elif message_type["type"] == b'\x26':
                    x26 += 1
                elif message_type["type"] == b'\x0b':
                    x0b += 1
                elif message_type["type"] == b'\x0d':
                    x0d += 1
                elif message_type["type"] == b'\x1a':
                    x1a += 1
                    if ign1a == "False":
                        keys = []
                        key_fast = message_type_full_parse["fastlog"]
                        for key in key_fast.keys():
                            if key == "latitude":
                                keys.append(key)
                            elif key == "longitude":
                                keys.append(key)
                        if "latitude" and "longitude" in keys:
                            key_lat = key_fast["latitude"]
                            key_lon = key_fast["longitude"]
                            for lat in key_lat:
                                pos_file["latitude"].append(lat)
                            for lon in key_lon:
                                pos_file["longitude"].append(lon)
                                msg_type = message_type_parse["type"]
                                pos_file["msg_type"].append(msg_type)
                                pos_c += 1
                elif message_type["type"] == b'\x1c':
                    x1c += 1
                elif message_type["type"] == b'\x1d':
                    x1d += 1
                elif message_type["type"] == b'\x02':
                    x02 += 1
                elif message_type["type"] == b'\x10':
                    x10 += 1
                elif message_type["type"] == b'\n':
                    continue
                elif message_type["type"] == b'"':
                    continue
                elif message_type["type"] == b'#':
                    continue
                elif message_type["type"] == b'\x0e':
                    x0e += 1
                else:
                    other_type_ttt.append(message_type["type"])

                if old_ts is not None:
                    ts_c += 1
                if message_type["type"] != b'\x1a':
                    if "latitude" in message_type_parse and \
                            "longitude" in message_type_parse:
                        lat = message_type_parse["latitude"]
                        lon = message_type_parse["longitude"]
                        msg_type = message_type_parse["type"]
                        pos_file["latitude"].append(lat)
                        pos_file["longitude"].append(lon)
                        pos_file["msg_type"].append(msg_type)
                        pos_c += 1

            if not other_type_ttt:
                other_type_ttt.append("None")
            if pos_file is not []:
                header_key = ["latitude", "longitude", "msg_type"]
                df = pd.DataFrame(pos_file)
                df.to_csv(f"{app.config['UPLOAD_PATH']}"
                          f"/{files[0]}_pos_file.csv", columns=header_key)

            mulogt.extend([x01, x04, x05, x08, x09, x13, x14, x25,
                           x26, x0b, x0d, x1a, x1c, x1d, x10,
                           x0e, other_type_ttt])
        except IOError:
            print("Error: File does not appear to exist.")
            # remove()
            return "Error: File does not appear to exist.", 400
        except ValueError:
            remove()
            text = f"ValueError: {ValueError}, file deleted"
            print(text)
            pass
    return render_template('mulog_read.html', files=files,
                           max_size=max_size, environment=environment,
                           environment_road=environment_road, mulog=mulogt,
                           ts_c=ts_c, pos_c=pos_c, text=text, warn=warn,
                           ign1a=ign1a, max_pos=max_pos,
                           _scheme="https", _external=True)
#  don't use use_scheme and _external with local testing


@app.route('/uploader', methods=['GET', 'POST'])
def uploader_file():
    if request.method == 'POST':
        app.config['IGN1A'] = request.form['ign1a']
        uploaded_file = request.files['file']
        filename = secure_filename(uploaded_file.filename)
        app.config['FILE_NAME'] = filename
        if filename != '':
            file_ext = os.path.splitext(filename)[1]
            if file_ext not in app.config['UPLOAD_EXTENSIONS']:
                return "Invalid file, supports only <b>.log</b> format", 400
            remove()
            uploaded_file.save(
                os.path.join(app.config['UPLOAD_PATH'], filename))

        return redirect(
            url_for('upload_file', _scheme="https", _external=True))
#  don't use use_scheme and _external with local testing


@app.route('/uploads/<filename>')
def upload(filename):
    return send_from_directory(app.config['UPLOAD_PATH'], filename)


@app.route('/call_remove')
def call_remove():
    remove()
    environment = request.host
    #  environment_road = f"http://{environment}/uploader"  # on local
    environment_road = f"https://{environment}/uploader"
    files = os.listdir(app.config['UPLOAD_PATH'])
    max_size = (app.config['MAX_CONTENT_LENGTH']) / (1024 * 1024)  # in mb
    return render_template('mulog_read.html', files=files,
                           max_size=max_size, environment=environment,
                           environment_road=environment_road, mulog=[],
                           _scheme="https", _external=True)
#  don't use use_scheme and _external with local testing


@app.route('/call_render')
def call_render():
    file_path = f"{app.config['UPLOAD_PATH']}/" \
                f"{app.config['FILE_NAME']}_pos_file.csv"
    file_ = pd.read_csv(file_path)
    file_use = file_[["latitude", "longitude"]]
    if file_use.empty:
        return f"Failed to render {file_path}, file positions empty.", 400
    else:
        map_ = folium.Map(location=[file_use.latitude.mean(),
                                    file_use.longitude.mean()],
                          zoom_start=14, control_scale=True)
        i_count = 0
        for _, row in file_use.iterrows():

            if row['latitude'] == "latitude":
                continue
            else:
                i_count += 1
                lat_lon = f"{i_count}\n{row['latitude']}\n{row['longitude']}"
                if i_count == 1:
                    folium.Marker([row['latitude'], row['longitude']],
                                  popup=f"First position: \n{lat_lon}",
                                  icon=folium.Icon(color="green",
                                                   icon="fas fa-truck"),
                                  ).add_to(map_)
                elif i_count == len(file_use):
                    folium.Marker([row['latitude'], row['longitude']],
                                  popup=f"Last position \n{lat_lon}",
                                  icon=folium.Icon(color="red",
                                                   icon="fas fa-truck"),
                                  ).add_to(map_)
                else:
                    folium.Marker([row['latitude'], row['longitude']],
                                  popup=f"{lat_lon}\n",
                                  ).add_to(map_)
        """
        points = []
                points.append(tuple([row['latitude'], row['longitude']]))
        folium.PolyLine(points, color="red",weight=2.5, opacity=1).add_to(map_)
        """
        return map_._repr_html_()  # https://fontawesome.com/


@app.errorhandler(413)
def too_large(e):
    return f"File is too large {e}, maximum is " \
           f"{(app.config['MAX_CONTENT_LENGTH']) / (1024 * 1024)}</b>mb", 413


@app.errorhandler(404)
def not_found(e):
    return f"Error: File does not appear to exist, {e}.", 404


@app.errorhandler(500)
def some_error(e):
    return f"{e}. Try <b>Clear</b> button", 500


def remove():
    print("deleted")
    folder = app.config['UPLOAD_PATH']
    for filename in os.listdir(folder):
        file_path = os.path.join(folder, filename)
        try:
            if os.path.isfile(file_path) or os.path.islink(file_path):
                os.unlink(file_path)
            elif os.path.isdir(file_path):
                shutil.rmtree(file_path)
        except Exception as e:
            return f"Failed to delete %s. Reason: {(file_path, e)}", 400


def listdir_nopos(path):
    r = []
    for _ in os.listdir(path):
        if not _.endswith('_pos_file.csv'):
            r.append(_)
    return r


"""
@app.route('/SomeFunction')
def SomeFunction():
    print('In SomeFunction')
     return "Nothing"


@app.route('/clear')
def SomeFunction2():
    print('In SomeFunction2')
    return "Nothing"


@app.route('/swmu_run')
def swmu_run():
    os.system(
    return "Nothing"
"""

if __name__ == '__main__':
    app.run(debug=True, host="0.0.0.0", port=50002)
    """
    app.run(debug=True, host="0.0.0.0", port=5000 2, ssl_context=(
        "server.crt", "server.key"
    ))
    """
    """
    app.run(debug=True, host="0.0.0.0", port=50002,
            ssl_context=('cert/cert.pem', 'cert/key.pem')
            )
    """