# app.py
from flask import Flask, request, jsonify, send_file
import random
from datetime import date # used for daily verse
import subprocess # use of "bible" system application for parsing and returning Bible in KJV0
import shlex # input security
import sqlite3
import string
DEBUG = 2
DEBUG_OUT = 0

"""
NOTES
- working on getting multi-search terms working right
Lookup_bookname does not like it lol.

To-do:
- Add data and function for Webster 1828 dictionary lookup
--https://github.com/DataWar/1828-dictionary
--https://github.com/mnjrupp/Android_SQLite_Dictionary_1828
--https://github.com/gapmiss/kingdom-study-tools-for-obsidian/tree/main/dictionary/
- Add data and function for Thesaurus to implement fuzzy search
--https://github.com/zaibacu/thesaurus
"""

def dbg(message):
    # if DEBUG is at or above a value of one, a call from debug level one will print red
    if DEBUG >= 1:
        print(f'\033[91m{message}\033[0m')
def dbg2(message):
    # if DEBUG is at or above a value of two, a call from debug level one will print green
    if DEBUG >= 2:
        print(f'\033[32m{message}\033[0m')
dbg("Debug Level 1 Enabled")
dbg2("Debug Level 2 Enabled")

kjv_db = sqlite3.connect("kjv.db")
kjv_cur = kjv_db.cursor()
verse_ids = [i[0] for i in kjv_cur.execute("SELECT id FROM t_kjv;").fetchall()]

app = Flask(__name__)

idx_id = 0
idx_book = 1
idx_chapter = 2
idx_verse = 3
idx_text = 4

def lookup_one_verse(verse_id):
    dbg("lookup_one_verse({})".format(verse_id))
    return(kjv_cur.execute("SELECT * FROM t_kjv WHERE id = {};".format(verse_id)).fetchone())

def lookup_bookname(book_id):
    dbg2("lookup_bookname({})".format(book_id))
    result = kjv_cur.execute("SELECT n FROM key_english WHERE b = {}".format(book_id)).fetchone()[0]
    dbg("lookup_bookname: {}".format(result))
    return result


def lookup_contains(kw):
    results = kjv_cur.execute("SELECT * FROM t_kjv WHERE t LIKE '%{}%';".format(kw)).fetchall()
    dbg("lookup_contains({}) {} results".format(kw,len(results)))
    return results

def lookup_contains_exact(kw):
    results = kjv_cur.execute("SELECT * FROM t_kjv WHERE t LIKE '%{}%';".format(kw)).fetchall()
    dbg("lookup_contains({}) {} results".format(kw,len(results)))
    return results

def response_dict(scripture):
    verse = {
        "bookname": lookup_bookname(scripture[idx_book]),
        "chapter": scripture[idx_chapter],
        "verse": scripture[idx_verse],
        "text": scripture[idx_text],
    }
    return (verse)

def response_text(scripture):
    bookname = lookup_bookname(scripture[idx_book])
    chapter = str(scripture[idx_chapter])
    verse = str(scripture[idx_verse])
    text = str(scripture[idx_text])
    return (bookname + " " + chapter + ":" + verse + " " + text)

def response_rich(scripture):
    css = open('human_readable.css', 'r')
    response_html = open('response.html', 'r')
    # passage, text

    bookname = lookup_bookname(scripture[idx_book])
    chapter = str(scripture[idx_chapter])
    verse = str(scripture[idx_verse])
    text = str(scripture[idx_text])

    passage = (bookname + " " + chapter + ":" + verse)

    return (response_html.read().format(passage = passage, text = text) + css.read())

def response_single(scripture):
    dbg2("response_single({})".format(scripture))
    arg_view = request.args.get("view", None)
    dbg("->requested_format = {}".format(arg_view))
    if arg_view == "plain":
        return(response_text(scripture))
    elif arg_view == "rich":
        return(response_rich(scripture))
    else:
        response = response_dict(scripture)
        return jsonify(response)

def response_multi(scriptures):
    dbg2("response_multi({})".format(scriptures))
    response = []
    arg_view = request.args.get("view", None)
    dbg("search ->requested_format = {}".format(arg_view))

    if arg_view == "plain":
        for scripture in scriptures:
            dbg2("for scripture in scriptures content: {}".format(scripture))
            response.append(response_text(scripture))
    elif arg_view == "rich":
        for scripture in scriptures:
            dbg2("for scripture in scriptures content: {}".format(scripture))
            response.append(response_rich(scripture))
    else:
        for scripture in scriptures:
            dbg2("for scripture in scriptures content: {}".format(scripture))
            response.append(response_dict(scripture))

    return(response)


def thesarus(word):
    return word
def dictionary(word):
    return word


@app.errorhandler(404)
def page_not_found(e):
    message = {"error": "You're lost! Isaiah 41:10 - Fear thou not; for I am with thee: be not dismayed; for I am thy God: I will strengthen thee; yea, I will help thee; yea, I will uphold thee with the right hand of my righteousness."}
    return jsonify(message)

@app.get("/")
def idx():
    return send_file("index.html")

#backwards-compatibility
@app.get('/t/random', defaults={'view':'plain'})
@app.get('/random')
def random_verse():
    rand_id = random.SystemRandom().choice(verse_ids)
    scripture = lookup_one_verse(rand_id)
    return(response_single(scripture))

#backwards-compatibility
@app.get('/t/votd', defaults={'view':'plain'})
@app.get('/votd')
def verse_of_the_day():
    today = int(str(date.today()).replace('-',''))
    #this is deterministic because of today's date being used as the seed
    random.seed(today)
    scripture = lookup_one_verse(random.choice(verse_ids))
    return(response_single(scripture))

# splits by delimiter then checks for any special characters
# if special characters are found, the query is rejected
def clean_keywords(kwds):
    kwds = kwds.split(',')
    for kwd in kwds:
        if not kwd.isalpha():
            return False
    dbg("clean_keywords = ({})".format(kwds))
    return kwds


def search_and(cleaned_keywords):
    results = []
    for keyword in cleaned_keywords:
        dbg("search->for keyword in database({})".format(keyword))
        #This is groups of results per word. Must check between groups.
        results.append(lookup_contains(keyword))
    return (results)

def search_any(cleaned_keywords):
    results = []
    for keyword in cleaned_keywords:
        dbg("search->for keyword in database({})".format(keyword))
        for result in lookup_contains(keyword):
            results.append(result)
    dbg("==> search_any: {} results".format(len(results)))
    return(results)


@app.get("/search")
def search():
    keywords = request.args.get("kw", None)
    dbg("search({})".format(keywords))
    if keywords:
        cleaned_keywords = clean_keywords(keywords)
        if not clean_keywords:
            return ("Invalid Query: Special Characters")
    else:
        return ("No Query")

    if request.args.get("operator",None) == "and":
        results = search_and(cleaned_keywords)
    else:
        results = search_any(cleaned_keywords)

    response_list = response_multi(results)

    arg_view = request.args.get("view", None)
    if arg_view == "plain" or arg_view == "rich":
        response = "<br>".join(response_list)
    else:
        response = jsonify(response_list)

    dbg2("Search Response: {}".format(response))
    return response


@app.get("/qwerty")
def test():
    style = css.read()
    return (style + "Hello! Testing!")

# plain
@app.get("/<passage>")
def passage_json(passage):
    try:
        command = "bible -f {}".format(shlex.quote(passage))
        result = str(subprocess.check_output(command, shell=True), "utf-8")
        if len(result) == 0:
            raise Exception("You have entered an incorrect syntax or your query returned no results.")
        return jsonify(result)
    except Exception as e:
        return jsonify(str(e))

# pretty
@app.get("/p/<passage>")
def passage_text(passage):
    try:
        command = "bible {}".format(shlex.quote(passage))
        result = str(subprocess.check_output(command, shell=True), "utf-8")
        if len(result) == 0:
            raise Exception("You have entered an incorrect syntax or your query returned no results.")
        return result
    except Exception as e:
        return str(e)


#search
@app.get("/s/<keyword>")
def search_json(keyword):
    try:
        command = "bible -f ??{}".format(shlex.quote(keyword))
        result = str(subprocess.check_output(command, shell=True), "utf-8")
        if len(result) == 0:
            raise Exception("You have entered an incorrect syntax or your query returned no results.")
        if result.contains("??word"):
            raise Exception("Not found.")
        result = result.split()
        result = result[7:]
        return jsonify(result)
    except Exception as e:
        return jsonify(str(e))

#search
@app.get("/sp/<keyword>")
def search_text(keyword):
    try:
        command = "bible -f ??{}".format(shlex.quote(keyword))
        result = str(subprocess.check_output(command, shell=True), "utf-8")
        if len(result) == 0:
            raise Exception("You have entered an incorrect syntax or your query returned no results.")
        if result.contains("??word"):
            raise Exception("Not found.")
        result = result.split()
        result = result[7:]
        result = '<br>'.join(map(str, result))
        return result
    except Exception as e:
        return str(e)

#search text json
@app.get("/sl/<keyword>")
def search_json_return(keyword):
    try:
        command = "bible -f ??{}".format(shlex.quote(keyword))
        result = str(subprocess.check_output(command, shell=True), "utf-8")
        if len(result) == 0:
            raise Exception("You have entered an incorrect syntax or your query returned no results.")
        if result.contains("??word"):
            raise Exception("Not found.")
        result = result.split()
        result = result[7:]
        complete_result = []
        for verse in result:
            complete_result.append(passage_text(verse))
        return jsonify(complete_result)
    except Exception as e:
        return str(e)

#search pretty
@app.get("/spl/<keyword>")
def search_text_return(keyword):
    try:
        command = "bible -f ??{}".format(shlex.quote(keyword))
        result = str(subprocess.check_output(command, shell=True), "utf-8")
        if len(result) == 0:
            raise Exception("You have entered an incorrect syntax or your query returned no results.")
        if result.contains("??word"):
            raise Exception("Not found.")
        result = result.split()
        result = result[7:]
        complete_result = []
        for verse in result:
            complete_result.append(passage_text(verse))
        result = '<br>'.join(map(str, complete_result))
        return result
    except Exception as e:
        return str(e)

#search pretty multiple
@app.get("/splm/<keywords>")
def search_text_return_multiple(keywords):
    if len(keywords.split('&')) > 1:
        pass
    try:
        command = "bible -f ??{}".format(shlex.quote(keyword))
        result = str(subprocess.check_output(command, shell=True), "utf-8")
        if len(result) == 0:
            raise Exception("You have entered an incorrect syntax or your query returned no results.")
        if result.contains("??word"):
            raise Exception("Not found.")
        result = result.split()
        result = result[7:]
        complete_result = []
        for verse in result:
            complete_result.append(passage_text(verse))
        result = '<br>'.join(map(str, complete_result))
        return result
    except Exception as e:
        return str(e)