import heapq, re, csv, os, shutil, datetime, urllib, sys
import itertools, time, markdown, csv, json, os.path, webbrowser, threading
from functools import wraps
from flask import Flask, request, send_from_directory, Response, render_template
from flask import send_file
from flask_socketio import SocketIO, emit
from werkzeug.routing import PathConverter
from queue import Queue
from textual.app import App, ComposeResult
from textual.containers import ScrollableContainer
from textual.widgets import Button, Footer, Header, Static
from importlib import reload 

import server
import localcache
from server import *
from canvas_secrets import flask_secretkey

from content import my_site




### SET THIS ENV VAR TO GET RELOADING
# (win)
# set FLASK_ENV=development
# (linux)
# export FLASK_ENV=development

import socket
this_host = socket.gethostname()

print('\n\n' + this_host, '\n\n')

has_curses = 0
if this_host != 'ROGDESKTOP':
    import curses
    has_curses = 1
else:
    print("Skipping curses stuff")

q = Queue() 


HOST_NAME = '192.168.1.6' # 
PORT_NUMBER = 8080 # Maybe set this to 9000.

datafile = 'lambda.csv'



####
####   This little web server is going to work with the "gui" folder / vue app
####
####



def dict_generator(indict, pre=None):
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, pre + [key]):
                    yield d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, pre + [key]):
                        yield d
            else:
                yield str(pre) + "   " + str([key, value]) + "\n"
    else:
        yield pre + [indict]
        yield str(pre) + "   " + str([indict]) + "\n"
        
 
 
def print_dict(v, prefix='',indent=''):
    if isinstance(v, dict):
        return [   print_dict(v2, "{}['{}']".format(prefix, k) + "<br />", indent+" " )  for k, v2 in v.items()  ]
    elif isinstance(v, list):
        return [ print_dict(  v2,  "{}[{}]".format(prefix , i) + "<br />", indent+" ")  for i, v2 in enumerate(v) ]
    else:
        return '{} = {}'.format(prefix, repr(v)) + "\n"
        

def walk_file():
    j = json.loads(open('cache/programs/programs_2.txt','r').read())
    
    return print_dict(j)


def tag(x,y): return "<%s>%s</%s>" % (x,y,x)

def tagc(x,c,y): return '<%s class="%s">%s</%s>' % (x,c,y,x)

def a(t,h): return '<a href="%s">%s</a>' % (h,t)

def server_save(key,value):
    codecs.open('cache/server_data.txt','a').write( "%s=%s\n" % (str(key),str(value)))

def flask_thread(q):
    #app = Flask(__name__, static_url_path='/cache', 
    #        static_folder='cache',)
    app = Flask(__name__)
    app.config['SECRET_KEY'] = flask_secretkey
    app.jinja_env.auto_reload = True
    socketio = SocketIO(app)

    app.config['TEMPLATES_AUTO_RELOAD'] = True

    def before_request():
        app.jinja_env.cache = {}

    app.before_request(before_request)
    
    

    @app.route('/mirror')
    def mirror():
        return codecs.open('cache/crawl/index.html','r','utf-8').read()
    
    
    @app.route('/mirror/<filename>')
    def mirror_file(filename):
        return markdown.markdown( codecs.open('cache/crawl/'+filename,'r','utf-8').read() ) + \
            "<pre>" + codecs.open('cache/crawl/'+filename,'r','utf-8').read() + "</pre>"

    @app.route('/clearscreens')
    def clears():
        clearscreens()
        return homepage()

    
    @app.route('/displaypi/on')
    def dpi():
        displaypi_on()
        return homepage()

    
    @app.route('/displaypi/off')
    def dpi2():
        displaypi_off()
        return homepage()

    
    @app.route('/screensoff')
    def screenoff_a():
        screenoff()
        return homepage()

    
    
    @app.route('/light')
    def light():
        desklight()
        return homepage()

    
    @app.route('/image/<filename>', methods=['GET','POST'])
    def do_image(filename):
        return image_edit(filename)

    @app.route('/imagecrop/<filename>/<x>/<y>/<w>/<h>/<newname>', methods=['GET','POST'])
    def do_image_crop(filename,x,y,w,h,newname):
        return image_crop(filename,x,y,w,h,newname)


    @app.route('/md', methods=['GET', 'POST'])
    def convert_markdown():
        if request.method == 'POST':
            markdown_input = request.form.get('markdown_input', '')
            html_output = markdown.markdown(markdown_input)
            return render_template('basic.html', title='md -> html', html_output=html_output)
        return render_template('convert.html')



    #
    #  SAVING STUFF
    #

    @app.route('/save', methods=['POST'])
    def save_post():
        now = datetime.now().strftime('%Y%m%dT%H%M')
        path = request.form['path']
        txt = request.form['content']
        
        try:
            o3 = codecs.open(server.writing_path + path, 'r', 'utf-8')
            orig_text = o3.read()
            o3.close()
        except Exception as e:
            orig_text = ''
            
        bu_filename = server.writing_path + 'older_copies/' + path + '_' + now + '.md'
        o2 = codecs.open( bu_filename, 'w', 'utf-8' )
        o2.write(orig_text)
        o2.close()
        print('wrote backup to %s.' % bu_filename)
        
        o1 = codecs.open(server.writing_path+path, 'w', 'utf-8')
        o1.write(txt)
        o1.close()
        return "<h1>Successfully Saved</h1><br>" + a('back to writing folder','/x/writing/index') + \
            " &nbsp; &nbsp; &nbsp; " + a('back to home','/')


    @app.route('/x/writing/images/<fname>')
    def writing_img(fname):
        # TODO
        img_path = "/media/hd2/peter_home/Documents/writing_img/"
        print(img_path + fname + " - writing images folder")
        img_ext = fname.split('.')[-1]
        if img_ext == "gif":
            return send_from_directory(img_path, fname)
        if img_ext == "jpg":
            return send_from_directory(img_path, fname)
        if img_ext == "png":
            return send_from_directory(img_path, fname)
        return send_from_directory(img_path, fname)

    # 
    # SERVER maintenance type stuff
    @app.route('/rl')
    def restart():
        reload(server)
        reload(localcache)
        return "Server code reloaded"

    @app.route("/x/<func>/<arg>/<arrg>")
    def dispatch3(func,arg,arrg):
        print("2 args")
        return "" + server_dispatch(func, arg, arrg)

    @app.route("/x/<func>/<arg>")
    def dispatch2(func,arg):
        print("1 arg")
        return "" + server_dispatch(func, arg)

    @app.route("/x/<func>")
    def dispatch(func):
        print("0 arg")
        return server_dispatch(func)

    @app.route("/api/<func>/<arg>/<arrg>")
    def dispatch3j(func,arg,arrg):
        print("json, 3 args")
        return Response(server_dispatch(func, arg, arrg), mimetype='text/json')

    @app.route("/api/<func>/<arg>")
    def dispatch2j(func,arg):
        print("json, 1 arg")
        return Response(server_dispatch(func, arg), mimetype='text/json')

    @app.route("/api/<func>")
    def dispatch1j(func):
        print("json, 0 arg")
        return Response(server_dispatch(func), mimetype='text/json')

    @app.route("/")
    def home():
        return server.homepage()
    
    #
    #  STATIC ROUTES
    #

    
    @app.route('/data/<path:path>')
    def send_cachedata(path):
        #myfile = os.path.join('cache', path).replace('\\','/')
        print(path)
        #return app.send_static_file(myfile)
        return send_from_directory('cache', path)




    # Departments, classes in each, and students (with hits) in each of those.

    """@app.route('/iii/<path:path>')
    def send_js(path):
        return send_from_directory('gui/dist', path)"""
    """@app.route('/lib/<path:path>')
    def send_jslib(path):
        return send_from_directory('gui/lib', path)"""
    
    #@app.route('/hello/')
    #@app.route('/hello/<name>')


    @app.route("/save/<key>/<val>")
    def s(key,val):
        server_save(key,val)
        return tag('h1','Saved.') + "<br />" + tag('p', 'Saved: %s = %s' % (str(key),str(val)))

    @app.route("/sample")
    def do_sample():
        return sample()
        

    @app.route('/podcast/media/<string:file_id>')
    def media(file_id):
        return send_file(LECPATH + urllib.parse.unquote(file_id), attachment_filename=urllib.parse.unquote(file_id))
 
    @app.route("/podcast")
    def podcast():
        return lectures()

    @app.route("/lectures")
    def weblec():
        return web_lectures()

 
    @app.route("/crazy")
    def hello():
        r = '<link rel="stylesheet" href="static/bootstrap.min.css">'
        r += tag('style', 'textarea { white-space:nowrap; }')
        r += tag('body', \
            tagc('div','container-fluid', \
                tagc('div','row', \
                    tagc( 'div', 'col-md-6', tag('pre', walk_file() ) ) + \
                    tagc( 'div', 'col-md-6', 'Column 2' + a('Shut Down','/shutdown' ) ) ) ) )
        
         
        
        return r
    
    @app.route("/sd")
    def sd():
        print('SIGINT or CTRL-C detected. Exiting gracefully')
        func = request.environ.get('werkzeug.server.shutdown')
        if func is None:
            raise RuntimeError('Not running with the Werkzeug Server')
        func()
        return "Server has shut down."
        
        
    @socketio.on('my event', namespace='/test')
    def test_message(message):
        print('received and event: "my event" from page. message is: %s' % message)
        emit('my response', {'data': 'got it! it is MYEVENT'})



    socketio.run(app, host= '0.0.0.0')     # , debug=True
    
    

def serve():
    x = threading.Thread(target=flask_thread, args=(q,))
    x.start()
    #webbrowser.open_new_tab("http://localhost:5000")
    
    y = threading.Thread(target=mqtt_loop)
    y.start()






class CanvasApp(App):
    """A Textual app to manage canvas."""

    BINDINGS = [("d", "toggle_dark", "Toggle dark mode")]

    def compose(self) -> ComposeResult:
        """Create child widgets for the app."""
        yield Header()
        yield Footer()

    def action_toggle_dark(self) -> None:
        """An action to toggle dark mode."""
        self.dark = not self.dark


def text_app():
    app = CanvasApp()
    app.run()


if __name__ == "__main__":
    options = { 1: ['start web server',serve] ,  
                2: ['start text app', text_app], 
              }
    print ('')

    if len(sys.argv) > 1 and re.search(r'^\d+',sys.argv[1]):
        resp = int(sys.argv[1])
        print("\n\nPerforming: %s\n\n" % options[resp][0])
    
    else:
        print ('')
        for key in options:
            print(str(key) + '.\t' + options[key][0])
        
        print('')
        resp = input('Choose: ')
    
    # Call the function in the options dict
    options[ int(resp)][1]()