import json, codecs, re, markdown, os, pypandoc, striprtf, sqlite3, random, urllib
import subprocess, html, time
from striprtf.striprtf import rtf_to_text
from flask import render_template, Response
from flask import send_from_directory
import hashlib, funcy, platform, requests
from datetime import datetime

from orgpython import to_html

from localcache import sqlite_file, db  # personnel_meta #  personnel_fetch
from localcache import user_enrolled_in
from localcache import arrange_data_for_web, depts_with_classcounts, dept_with_studentviews, course_quick_stats


from yattag import Doc


import socket
this_host = socket.gethostname()
print('\n\n server host: ' + this_host, '\n\n')

datafile2 = "cache/datafile.txt"


LECPATH = "/media/hd2/peter_home_offload/lecture/"
host = 'http://192.168.1.6:5000'
news_path = '/media/hd2/peter_home/Documents/scripts/browser/'
writing_path = '/media/hd2/peter_home/Documents/writing/'
img_path = '/media/hd2/peter_home/Documents/writing_img/'
pics_path = '/media/hd2/peter_home/misc/'


if this_host == 'ROGDESKTOP':
    LECPATH = "d:/peter_home_offload/lecture/"
    host = 'http://192.168.1.7:5000'
    news_path = 'd:/peter_home/Documents/scripts/browser/'
    writing_path = 'd:/peter_home/Documents/writing/'
    img_path = 'd:/peter_home/Documents/writing_img/'
    pics_path = 'd:/peter_home/misc/'





   




import paho.mqtt.client as mqtt


#################################################################################################################
#################################################################################################################
######
######      mqtt
######



client = 0

mqtt_offline = 1

mqtt_time = 0.1


def mqtt_loop():
    while 1:
        if client and not mqtt_offline:
            client.loop(mqtt_time)


# called when MQTT server connects
def on_connect(client, userdata, flags, rc):
    print("Connected with result code "+str(rc))
    client.subscribe("local/#")

# The callback for when a PUBLISH message is received from the server.
def on_message(client, userdata, msg):
    now = datetime.now().strftime('%Y %m %d  %H %M')
    print("    %s  mqtt msg: %s    data: %s"  % (now, msg.topic, msg.payload.decode()))


if 0:
    while(mqtt_offline):
        try:
            client = mqtt.Client()
            client.on_connect = on_connect
            client.on_message = on_message

            client.connect("192.168.1.6", 1883, 60)

            mqtt_offline = 0

        except OSError as oe:
            print('no internet? try again in 5 seconds.')
            time.sleep(5)



def displaypi_on():
    global client
    msg = 'local/frame_on'
    client.publish(msg, 'webserver')
    print("sent %s" % msg)

def displaypi_off():
    global client
    msg = 'local/frame_off'
    client.publish(msg, 'webserver')
    print("sent %s" % msg)

def desklight():
    global client
    
    msg = 'local/peter/desklamps'
    client.publish(msg, 'webserver')
    print("sent %s" % msg)

def clearscreens():
    global client
    
    msg = 'local/clearscreens'
    client.publish(msg, 'webserver')
    print("sent %s" % msg)

def screenoff():
    global client
    
    msg = 'local/peter/monitors'
    client.publish(msg, 'webserver')
    print("sent %s" % msg)



#################################################################################################################
#################################################################################################################
######
######      writing & knowledgebase
######



br = "<br />"
nl = "\n"
style = """<style> body { line-height: 2.3em; margin: 4em; } 
</style><link rel="stylesheet" href="/data/gui/public/simplemde.min.css">
<script src="/data/gui/public/simplemde.min.js"></script>"""


## I implement the backend of a web based GUI for the canvas functions
## and dashboard stuff.


## Stories / Next Steps

## 1. browse my writings. Follow links in markdown format to other files
##    in this folder. html, md, rtf are handled so far. 

## 2a. Sort by date, title, topic/tag

## 2b. Use w/ larger topic modeling project to suggest relations

## 2. Run through everything in the folder, and index the 'backlinks'.
##    Append those to each file.

## 3 (interrupted)  Use vue and implement editing. Q: convert back to
##   original format? Or maintain new one. A: Convert back. 

## 3. Do similar for tags. 

## 4. Do similar but automatically, using nlp and keywords. 



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 homepage():
    #output = pypandoc.convert_file(writing_path+fname, 'html', format="rst")
    return tag('h1','This is my server.') + "<br />" + \
            a('Toggle light','/light') + br + br + \
            a('Clear screens','/clearscreens') + br + br + \
            a('Toggle monitors','/screensoff') + br + br + \
            a('Pi frame on','/displaypi/on') + br + br + \
            a('Pi frame off','/displaypi/off') + br + br + \
            a('Knowledge Base','/x/writing/index') + br + \
            a('Gav web mirror','/mirror') + br + \
            a('Graph of users','/x/user/1') + "<br />" + \
            a('Courses in a dept','/x/dept/csis') + "<br />" + \
            a('People in a course','/x/roster/10633') + br + br + \
            a('Summarize courses a user has been seen in','/x/user_course_history_summary/9964') + br + br + \
            a('Peters Lecture Series','/lectures') + br + br + \
            a('Reload server','/rl') + "<br />" + \
            a('want to shut down?','/sd') + "<br />" + \
            a('', '') + br

def orgline(L):
    L.strip()
    if re.search("^\s*$", L): return ""

    a = re.search( '^\*\s(.*)$', L)
    if a: return "<h2>%s</h2>\n" % a.group(1)

    b = re.search( 'TODO\s\[\#A\](.*)$', L)
    if b: return "<b><i>Todo - Priority 1</i>: %s</b>" % b.group(1)  + br + nl

    d = re.search( '^\*\*\*\s(.*)$', L)
    if d: return d.group(1)
    d = re.search( '^\*\*\s(.*)$', L)
    if d: L = d.group(1)

    return L + br + nl

def editor(src):
    return br + br + br + """<textarea name='content' id='editor'>%s</textarea><script>
var simplemde = new SimpleMDE({ element: document.getElementById("editor") });
</script>""" % src

def in_form(txt,path):
    return '<form method="post" action="/save"><input type="hidden" name="what" value="writing">' + \
            '<input type="hidden" name="path" value="' + path + '" />' + \
            txt + \
            '<input type="submit" value="Save" name="Save" /></form>'

def mytime(fname):
    return os.path.getmtime( os.path.join(writing_path, fname) )

def index():
    #f = [ os.path.join(writing_path, x) for x in os.listdir(writing_path) ]
    f = os.listdir(writing_path)
    f.sort(key=mytime)
    f.reverse()
    return "<br /><br />\n".join(  ["<a href='%s'>%s</a> (%s)" % (x,x,datetime.fromtimestamp(mytime(x)).strftime('%Y-%m-%d %H')) for x in f ] )

def writing(fname):
    
    if fname == 'index': return index()
    inp = codecs.open(writing_path + fname, 'r', 'utf-8')
    ext = fname.split('.')[-1]
    if ext == "py" or ext == "php":
        src = inp.read()
        return "<pre>" + html.escape(src) + "</pre>"
    if ext == "html":
        src = inp.read()
        return src
    if ext == "md":
        src = inp.read()
        return style + markdown.markdown(src) + in_form(editor(src),fname)
    if ext == "org":
        src = inp.read()
        return to_html(src, toc=True, offset=0, highlight=True)
    if ext == "rtf":
        text = "<br />\n".join( rtf_to_text(inp.read()).split('\n') )
        return style + text
    if ext == "docx":
        hash = hashlib.sha1("my message".encode("UTF-8")).hexdigest()
        hash = hash[:10]
        #output = pypandoc.convert_file('C:/Users/peter/Nextcloud/Documents/writing/' + fname, 'html',
        output = pypandoc.convert_file(writing_path + fname, 'html',
                extra_args=['--extract-media=%s' % hash ])     #   file:///c:/Users/peter/Nextcloud/Documents/writing
        return style + output
    return style + markdown.markdown( "".join( [ orgline(x) for x in inp.readlines() ] ) )




#################################################################################################################
#################################################################################################################
######
######      kiosk display
######

def dashboard():
    return open('static/slides.html','r').read()  # tag('h1','Dashboard') + br + a('home', '/')

def dash():
    return open('static/dashboard.html','r').read()  # tag('h1','Dashboard') + br + a('home', '/')

def mycalendar():
    ics = 'https://calendar.google.com/calendar/u/0?cid=cGV0ZXIuaG93ZWxsQGdtYWlsLmNvbQ'
    return dash()
    
def most_recent_file_of( target, folder ):

    def finder(st):
        return re.search(target,st)

    all = os.listdir(folder)
    all.sort(key=lambda x: os.stat(os.path.join(folder,x)).st_mtime)
    all.reverse()
    all = list(funcy.filter( finder, all ))

    print("file list is: " + str(all))
    if not all:
        return ''
    return all[0]

def news():
    folder = most_recent_file_of( r'\d\d\d\d\d\d\d\d', news_path )
    pics = os.listdir( news_path + folder )
    return '/static/news/' + folder + '/' + random.choice(pics)

def randPic():
    now = datetime.now()
    
    if now.minute < 15:
        return news()
    return '/static/images/' + random.choice(os.listdir('static/images'))






def do_img_crop(im):
    result = subprocess.run(['ls', '-l'], stdout=subprocess.PIPE)
    rr = result.stdout.decode('utf-8')





#################################################################################################################
#################################################################################################################
######
######      db info helpers
######

def sample():
    return "<h1>I am a sample</h1>"

def sample2(a=""):
    return "I'm a placeholder"

# Filter a stream of loglines for those that match a course's url / id
def has_course(stream,courseid):
    regex = '/courses/%i/' % int(courseid)
    while True:
        L = stream.readline()
        if re.search(regex, L): yield L

def js(s):
    return json.dumps(s, indent=2)

def sem_from_array_crn(crn):
    if not crn[2]: return ""
    if crn[2] == "": return ""
    return crn[2][:6]


#################################################################################################################
#################################################################################################################
######
######      db ilearn course / user / hits
######

def user_courses(uid):
    return js(user_enrolled_in(uid))

def user_course_history_summary(usr_id):
    q = """SELECT r.timeblock, r.viewcount, c.sis, c.code, c.canvasid FROM requests_sum1 AS r 
JOIN users AS u ON r.userid=u.id 
JOIN courses AS c ON c.id=r.courseid 
WHERE u.canvasid=%s
GROUP BY r.courseid ORDER BY r.viewcount DESC;""" % str(usr_id)
    (conn,cur) = db()
    cur.execute(q)
    r = cur.fetchall()
    return js(r)
    groups = funcy.group_by(sem_from_array_crn, r)
    g = {}
    for K in groups.keys(): g[K] =    [ x[3] for x in groups[K] ] 
    return js( g )

def roster(crn):
    q = """SELECT u.name, u.sortablename, u.canvasid as user_id, c.canvasid as course_id, e.workflow, e."type" FROM enrollment AS e 
JOIN users AS u ON e.user_id=u.id 
JOIN courses AS c ON c.id=e.course_id 
WHERE c.canvasid="%s" ;""" % str(crn)
    (conn,cur) = db()
    cur.execute(q)
    return js(cur.fetchall())


def user_course_hits(usr,courseid):
    return list(has_course( codecs.open('cache/users/logs/%s.csv' % usr, 'r', 'utf-8'), courseid))
    #return "\n".join( [x for x in next(gen)] )

def profiles(id=1,b=2,c=3):
    import os
    pics = os.listdir('cache/picsCanvas')
    return ''.join([ "<img height='45' width='45' hspace='5' vspace='5' src='/cache/picsCanvas/%s' />" % s for s in pics ])


# Departments, classes in each, and students (with hits) in each of those.
def enrollment(a):
    return js(depts_with_classcounts())

# All the classes in this dept, w/ all the students in each, with count of their views.
def dept(d=''):
    if not d: return js(dept_with_studentviews())
    return js(dept_with_studentviews(d))


def user(canvas_id=None):
    info = json.loads(  codecs.open( 'cache/users/%s.txt' % canvas_id, 'r', 'utf-8').read() )
    return render_template('hello.html', id=canvas_id, name=info['name'])












#################################################################################################################
#################################################################################################################
######
######      podcast feed
######


def lectures():
    fi = os.listdir(LECPATH)
    doc, tag, text = Doc().tagtext()
    doc.asis('<?xml version="1.0" encoding="UTF-8"?>')
    doc.asis('<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" version="2.0">')
    with tag('channel'):
        with tag('title'): text("Peter's Lecture Series")
        with tag('description'): text("Since 2019")
        with tag('link'): text(host)
        for f in fi:
            if f.endswith('.mp3'):
                #print(f)
                with tag('item'):
                    name = f.split('.')[0]
                    ff = re.sub('\s','%20',f)
                    with tag('title'): text(name)
                    with tag('guid'): text(f)
                    b = os.path.getsize(LECPATH+f)
                    doc.stag('enclosure', url=host+'/podcast/media/'+urllib.parse.quote(ff), type='audio/mpeg',length=b)
    doc.asis('</rss>')
    #doc.asis('</xml>')
    return doc.getvalue()

def web_lectures():
    fi = os.listdir(LECPATH)
    output = "<h1>Lectures</h1>\n"
    for f in fi:
        if f.endswith('.mp3'):
            name = f.split('.')[0]
            ff = urllib.parse.quote(f)
            #ff = re.sub('\s','%20',f)
            output += '<a href="%s">%s</a><br />\n' % ( host + '/podcast/media/' + ff, name)
    return output





#################################################################################################################
#################################################################################################################
######
######      editing personnel app
######


# personnel_fetch, personnel_meta

# todo: update: dept, title, any of the other fields. 
#       insert: new dept, new title, 

# update a value: dept id of a personnel id
def update_pers_title(pid, tid):
    q = "UPDATE personnel SET `title`='%s' WHERE `id`='%s'" % (str(tid), str(pid))
    (conn,cur) = db()
    result = cur.execute(q)
    conn.commit()
    return js(  {'result': 'success'} )

# update a value: dept id of a personnel id
def update_pers_dept(pid, did):
    q = "UPDATE personnel SET `dept1`='%s' WHERE `id`='%s'" % (str(did), str(pid))
    (conn,cur) = db()
    result = cur.execute(q)
    conn.commit()
    return js(  {'result': 'success'} )



def user_edit(canvas_id='2'):
    info = json.loads(  codecs.open( 'cache/users/%s.txt' % str(canvas_id), 'r', 'utf-8').read() )
    return render_template('personnel.html', id=canvas_id, name=info['name'])
    
def staff_dir(search=''):
    return render_template('dir.html')

    
    
    
    
######
######      handling images
######


def find_goo(n):
    g = re.search('00(\d\d\d\d\d\d)', n)
    
    if g:
        return g.groups()[0]
    return ''


def byname(x): 
    if 'conf_name' in x: 
        return x['conf_name']
    if 'first_name' in x and 'last_name' in x:
        return x['first_name'] + " " + x['last_name']
    return ''

def fn_to_struct( n, staff ):
    g = find_goo(n)
    if g: 
        #print(g)
        for s in staff:
            cg = s['conf_goo']
            if cg == g: 
                #print("%s - %s - %s" % (n, g, cg) )
                return s
        return { "conf_goo":g, "conf_name":"unknown - " + n }
    return 0
            
def image_edit(filename=''):
    
    url = "https://hhh.gavilan.edu/phowell/map/dir_api_tester.php?a=list/staffsemester"
    staff = json.loads( requests.get(url).text )
    
    badges = 0
    web = 1
    
    if web:
        files = sorted(os.listdir('cache/picsStaffdir') )
        done_files = [ x[:-4] for x in sorted(os.listdir('cache/picsStaffdir/cropped') ) ]

    
    if badges:
        files = sorted(os.listdir('cache/picsId/originals_20211022') )
        done_files = [ x[:6] for x in sorted(os.listdir('cache/picsId/2021crop') ) ]
    
    files_match = []
    files_no_match = []
    raw_filenames = files
    
    for f in files:
        sa = fn_to_struct(f,staff)
        if sa:
            ss = sa.copy()
        else:
            ss = sa
        if ss: 
            ss['filename'] = f
            files_match.append(ss)
        else: files_no_match.append(f)
    
    
    fm = json.dumps( sorted(files_match,key=byname) )
    fnm = json.dumps(files_no_match)
    sm = json.dumps(staff)
        
    
    return render_template('images.html', staff=sm, matches=fm, nomatches=fnm, checked=done_files)



def image_crop(filename,x,y,w,h,newname=''):
    from PIL import Image
    import piexif
    
    badges = 0
    web = 1

    if not newname: newname = filename
    
    if web:
        im = Image.open('cache/picsStaffdir/%s' % filename)
        savepath = 'cache/picsStaffdir/cropped/%s.jpg' % newname
    
    if badges:
        im = Image.open('cache/picsId/originals_20211022/%s' % filename)
        savepath = 'cache/picsId/2021crop/%s.jpg' % newname

    out = { 'im': str(im) }
    
    x = int(x)
    y = int(y)
    w = int(w)
    h = int(h)
    
    
    if "exif" in im.info:
        exif_dict = piexif.load(im.info['exif'])
        #out['exif'] = exif_dict
        #print(exif_dict)

        if piexif.ImageIFD.Orientation in exif_dict['0th']:
            #exif_dict['0th'][piexif.ImageIFD.Orientation] = 3
            print(piexif.ImageIFD.Orientation)
            print(exif_dict['0th'])
            out['rotation'] = 'messed up'
            
            if exif_dict['0th'][piexif.ImageIFD.Orientation] == 6:
                im = im.rotate(270, expand=True)
                #im.save('cache/picsId/originals_20211022/crotated_%s' % filename, quality=95)



    
    im_crop = im.crop((x,y,x+w,y+h))
    img_resize = im_crop.resize((250, 333))
    img_resize.save(savepath, quality=95)
    return json.dumps( out )



    #if filename=='list':
    #    #return '<br />\n'.join([ "<a href='/data/picsId/originals_20211022/%s'>%s</a>" % ( x,x ) for x in 
    #    return '<br />\n'.join([ "<a href='/image/%s'>%s</a>" % ( x,x ) for x in sorted(os.listdir('cache/picsId/originals_20211022')) ])
    


#################################################################################################################
#################################################################################################################
######
######      server infrastructure
######



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


def server_dispatch_json(function_name,arg='', arg2=''):
    print("Looking for function: %s. arg:%s. arg2:%s." % (function_name, arg, arg2))
    try:
        result = "" + globals()[function_name](arg, arg2)
        print("doing 2 args")
        return result
    except Exception as e:
        print("Error with that: %s" % str(e))
        try:
            result = "" + globals()[function_name](arg)     # 
            print("doing 1 arg")
            return result
        except Exception as f:
            print("Error with that: %s" % str(f))
            try:
                result = globals()[function_name]()
                print("doing 0 arg")
                return result
            except Exception as gg:
                print("Error with that: %s" % str(gg))
                return json.dumps({'result':'failed: exception', 'e1':str(e), 'e2':str(f), 'e3':str(gg)}, indent=2)
        

def server_dispatch(function_name,arg='', arg2=''):
    print("Looking for function: %s. arg:%s. arg2:%s." % (function_name, arg, arg2))
    try:
        result = "" + globals()[function_name](arg, arg2)
        print("doing 2 args")
        return result
    except Exception as e:
        print("Error with that: %s" % str(e))
        try:
            result = "" + globals()[function_name](arg)     # 
            print("doing 1 arg")
            return result
        except Exception as f:
            print("Error with that: %s" % str(f))
            try:
                result = globals()[function_name]()
                print("doing 0 arg")
                return result
            except Exception as gg:
                print("Error with that: %s" % str(gg))
                return json.dumps({'result':'failed: exception', 'e1':str(e), 'e2':str(f), 'e3':str(gg)}, indent=2)