from flask import Flask, request
from flask_restful import Resource, Api, reqparse
from datetime import date, timedelta
import configparser
import csv
import ast
import glob
import json, operator
import sqlite3
api_app = Flask(__name__)
api = Api(api_app)

def read_config():
    config = configparser.ConfigParser()
    config.read('config.ini')
    return config

def read_logs(log_folder):
    # Read some log files
    # UTC time, so let's look at tomorrow, today, and yesterday.
    today = date.today()
    yesterday = today - timedelta(days = 1)
    tomorrow = today + timedelta(days = 1)
    file_list = glob.glob(log_folder+str(yesterday)+"*") + \
                glob.glob(log_folder+str(today)+"*") + \
                glob.glob(log_folder+str(tomorrow)+"*")

    # https://stackoverflow.com/a/66071962
    json_array = []
    for file in file_list:
        with open(file, encoding='utf-8') as csvf:
            csvReader = csv.DictReader(csvf)
            for row in csvReader:
                #add this python dict to json array
                json_array.append(row)

    # Add the call and location of this station to the packet info
    config = read_config()
    for item in json_array:
        item['station_name'] = config['Settings']['station_call']
        item['station_lat'] = config['Settings']['station_lat']
        item['station_lon'] = config['Settings']['station_lon']

    return(json_array)

def dict_factory(cursor, row):
    d = {}
    for idx, col in enumerate(cursor.description):
        d[col[0]] = row[idx]
    return d

def get_db_connection():
    conn = sqlite3.connect('database.db')
    conn.row_factory = dict_factory
    return conn

def select_all_frames(conn):
    """
    Query all rows in the frames table
    :param conn: the Connection object
    :return:
    """
    cur = conn.cursor()
    cur.execute("SELECT * FROM frames")
    rows = cur.fetchall()
    return rows

def select_frames(conn, n, from_):
    cur = conn.cursor()
    # Workaround to deal with missing value in WHERE
    from_ = "IS NOT NULL" if from_ == None else "='"+from_+"'"
    #sql = "SELECT * FROM frames LIMIT "+n
    sql = 'SELECT * FROM frames WHERE "from" {from_} ORDER BY created DESC LIMIT {n}'.format(from_=from_, n=n)
    print(sql)
    cur.execute(sql)
    rows = cur.fetchall()
    return rows

class Packets(Resource):
    def get(self):
        # Handle arguments that may or may not exist
        try:
            n = int(request.args.get('n'))
        except:
            n = 10
        from_ = None if request.args.get('from') == None else request.args.get('from')

        conn = get_db_connection()
        # Limit to number of records requested
        data = select_frames(conn, n = n, from_ = from_)
        # Sort by created date, descending (https://stackoverflow.com/a/45266808)
        #data.sort(key=operator.itemgetter('created'), reverse=True)
        return {'data': data}, 200  # return data and 200 OK code

# Read config
config = read_config()
log_folder = config['Settings']['log_folder']

# Start subprocess to watch KISS connection
import subprocess
subprocess.Popen(["python3","kiss_and_db.py"])

api.add_resource(Packets, '/packets')  # and '/locations' is our entry point for Locations

if __name__ == '__main__':
    api_app.run(debug=True, host='0.0.0.0', port=5001)  # run our Flask app