from django.conf import settings
#from . import fileAbstraction
from django.shortcuts import render_to_response
from django.http import HttpResponse, Http404
import os, stat
import re
from troggle.core.models_survex import SurvexScansFolder, SurvexScanSingle, SurvexBlock, TunnelFile
import parsers.surveys
import urllib.request, urllib.parse, urllib.error

# inlined use of fileabstraction into here 

def fa_listdir(*path):
    try:
        strippedpath = [p for p in path if p]
        root = os.path.join(settings.FILES, *strippedpath )
        l = ""
        #l = root + "\n"
        isdir = os.path.isdir(root) #This seems to be required for os.path.isdir to work...
        #l += str(isdir) + "\n"
        for p in os.listdir(root):
            if os.path.isdir(os.path.join(root, p)):
                l += p + "/\n"
                
            elif os.path.isfile(os.path.join(root, p)):
                l += p + "\n"
            #Ignore non-files and non-directories
        return l
    except:
        if strippedpath:
            c = reduce(urljoin, strippedpath)
        else:
            c = ""
        c = c.replace("#", "%23")
        print(("FILE: ", settings.FILES + "listdir/" + c))
        return urllib.request.urlopen(settings.FILES + "listdir/" + c).read()
        
def fa_readFile(*path):
    try:
        f = open(os.path.join(settings.FILES, *path))
    except:
        f = urllib.request.urlopen(settings.FILES + "download/" + reduce(urljoin, path))
    return f.read()
    
def getMimeType(extension):
    try:
        return {"txt": "text/plain",
                "html": "text/html",
                }[extension]
    except:
        print("unknown file type")
        return "text/plain"


def listdir(request, path):
    #try:
        return HttpResponse(fa_listdir(path), content_type="text/plain")
    #except:
    #    raise Http404

def upload(request, path):
    pass

def download(request, path):
    #try:
        
        return HttpResponse(fa_readFile(path), content_type=getMimeType(path.split(".")[-1]))
    #except:
    #    raise Http404


#
# julian's quick hack for something that works
# could signal directories by ending with /, and forward cases where it's missing
#
extmimetypes = {".txt": "text/plain",
             ".html": "text/html",
             ".png": "image/png",
             ".jpg": "image/jpeg",
             ".jpeg": "image/jpeg",
            }
            
# dead
def jgtfile(request, f):
    fp = os.path.join(settings.SURVEYS, f)
    # could also surf through SURVEX_DATA
    
    # directory listing
    if os.path.isdir(fp):
        listdirfiles = [ ]
        listdirdirs = [ ]
        
        for lf in sorted(os.listdir(fp)):
            hpath = os.path.join(f, lf)  # not absolute path
            if lf[0] == "." or lf[-1] == "~":
                continue
            
            hpath = hpath.replace("\\", "/")  # for windows users
            href = hpath.replace("#", "%23")  # '#' in file name annoyance
            
            flf = os.path.join(fp, lf)
            if os.path.isdir(flf):
                nfiles = len([sf  for sf in os.listdir(flf)  if sf[0] != "."])
                listdirdirs.append((href, hpath + "/", nfiles))
            else:
                listdirfiles.append((href, hpath, os.path.getsize(flf)))
                
        upperdirs = [ ]
        lf = f
        while lf:
            hpath = lf.replace("\\", "/")  # for windows users
            if hpath[-1] != "/":
                hpath += "/"
            href = hpath.replace("#", "%23")
            lf = os.path.split(lf)[0]
            upperdirs.append((href, hpath))
        upperdirs.append(("", "/"))
            
        return render_to_response('listdir.html', {'file':f, 'listdirfiles':listdirfiles, 'listdirdirs':listdirdirs, 'upperdirs':upperdirs, 'settings': settings})
    
    # flat output of file when loaded
    if os.path.isfile(fp):
        ext = os.path.splitext(fp)[1].lower()
        mimetype = extmimetypes.get(ext, "text/plain")
        fin = open(fp)
        ftext = fin.read()
        fin.close()
        return HttpResponse(ftext, content_type=mimetype)

    return HttpResponse("unknown file::%s::" % f, content_type = "text/plain")


def UniqueFile(fname):
    while True:
        if not os.path.exists(fname):
            break
        mname = re.match("(.*?)(?:-(\d+))?\.(png|jpg|jpeg)$(?i)", fname)
        if mname:
            fname = "%s-%d.%s" % (mname.group(1), int(mname.group(2) or "0") + 1, mname.group(3))
    return fname


# join it all up and then split them off for the directories that don't exist
# anyway, this mkdir doesn't work
def SaveImageInDir(name, imgdir, project, fdata, bbinary):
    print(("hihihihi", fdata, settings.SURVEYS))
    fimgdir = os.path.join(settings.SURVEYS, imgdir)
    if not os.path.isdir(fimgdir):
        print("*** Making directory", fimgdir)
        os.path.mkdir(fimgdir)
    fprojdir = os.path.join(fimgdir, project)
    if not os.path.isdir(fprojdir):
        print("*** Making directory", fprojdir)
        os.path.mkdir(fprojdir)
        print("hhh")
        
    fname = os.path.join(fprojdir, name)
    print(fname, "fff")
    fname = UniqueFile(fname)
    
    p2, p1 = os.path.split(fname)
    p3, p2 = os.path.split(p2)
    p4, p3 = os.path.split(p3)
    res = os.path.join(p3, p2, p1)
    
    print("saving file", fname)
    fout = open(fname, (bbinary and "wb" or "w"))
    fout.write(fdata.read())
    fout.close()
    res = os.path.join(imgdir, name)
    return res.replace("\\", "/")


# do we want to consider saving project/field rather than field/project
def jgtuploadfile(request):
    filesuploaded = [ ]
    project, user, password, tunnelversion = request.POST["tunnelproject"], request.POST["tunneluser"], request.POST["tunnelpassword"], request.POST["tunnelversion"]
    print((project, user, tunnelversion))
    for uploadedfile in list(request.FILES.values()):
        if uploadedfile.field_name in ["tileimage", "backgroundimage"] and \
                        uploadedfile.content_type in ["image/png", "image/jpeg"]:
            fname = user + "_" + re.sub("[\\\\/]", "-", uploadedfile.name) # very escaped \
            print(fname)
            fileuploaded = SaveImageInDir(fname, uploadedfile.field_name, project, uploadedfile, True)
            filesuploaded.append(settings.URL_ROOT + "/jgtfile/" + fileuploaded)
        if uploadedfile.field_name in ["sketch"] and \
                        uploadedfile.content_type in ["text/plain"]:
            fname = user + "_" + re.sub("[\\\\/]", "-", uploadedfile.name) # very escaped \
            print(fname)
            fileuploaded = SaveImageInDir(fname, uploadedfile.field_name, project, uploadedfile, False)
            filesuploaded.append(settings.URL_ROOT + "/jgtfile/" + fileuploaded)
    #print "FF", request.FILES
    #print ("FFF", request.FILES.values())
    message = ""
    print("gothere")
    return render_to_response('fileupload.html', {'message':message, 'filesuploaded':filesuploaded, 'settings': settings})

def surveyscansfolder(request, path):
    #print [ s.walletname  for s in SurvexScansFolder.objects.all() ]
    survexscansfolder = SurvexScansFolder.objects.get(walletname=urllib.parse.unquote(path))
    return render_to_response('survexscansfolder.html', { 'survexscansfolder':survexscansfolder, 'settings': settings })

def surveyscansingle(request, path, file):
    survexscansfolder = SurvexScansFolder.objects.get(walletname=urllib.parse.unquote(path))
    survexscansingle = SurvexScanSingle.objects.get(survexscansfolder=survexscansfolder, name=file)
    return HttpResponse(content=open(survexscansingle.ffile,"rb"), content_type=getMimeType(path.split(".")[-1]))
    #return render_to_response('survexscansfolder.html', { 'survexscansfolder':survexscansfolder, 'settings': settings })
    
def surveyscansfolders(request):
    survexscansfolders = SurvexScansFolder.objects.all()
    return render_to_response('survexscansfolders.html', { 'survexscansfolders':survexscansfolders, 'settings': settings })
    
    
def tunneldata(request):
    tunnelfiles = TunnelFile.objects.all()
    return render_to_response('tunnelfiles.html', { 'tunnelfiles':tunnelfiles, 'settings': settings })
    

def tunnelfile(request, path):
    tunnelfile = TunnelFile.objects.get(tunnelpath=urllib.parse.unquote(path))
    tfile = os.path.join(settings.TUNNEL_DATA, tunnelfile.tunnelpath)
    return HttpResponse(content=open(tfile), content_type="text/plain")
    
def tunnelfileupload(request, path):
    tunnelfile = TunnelFile.objects.get(tunnelpath=urllib.parse.unquote(path))
    tfile = os.path.join(settings.TUNNEL_DATA, tunnelfile.tunnelpath)
    
    project, user, password, tunnelversion = request.POST["tunnelproject"], request.POST["tunneluser"], request.POST["tunnelpassword"], request.POST["tunnelversion"]
    print((project, user, tunnelversion))
    
    
    assert len(list(request.FILES.values())) == 1, "only one file to upload"
    
    uploadedfile = list(request.FILES.values())[0]
        
    if uploadedfile.field_name != "sketch":
        return HttpResponse(content="Error: non-sketch file uploaded", content_type="text/plain")
    if uploadedfile.content_type != "text/plain":
        return HttpResponse(content="Error: non-plain content type", content_type="text/plain")
        
    # could use this to add new files
    if os.path.split(path)[1] != uploadedfile.name:  
        return HttpResponse(content="Error: name disagrees", content_type="text/plain")
    
    orgsize = tunnelfile.filesize   # = os.stat(tfile)[stat.ST_SIZE]
        
    ttext = uploadedfile.read()
    
    # could check that the user and projects agree here
    
    fout = open(tfile, "w")
    fout.write(ttext)
    fout.close()
    
    # redo its settings of 
    parsers.surveys.SetTunnelfileInfo(tunnelfile)
    tunnelfile.save()
    
    uploadedfile.close()
    message = "File size %d overwritten with size %d" % (orgsize, tunnelfile.filesize)
    return HttpResponse(content=message, content_type="text/plain")