import string
import os
import datetime
import logging
import re
from subprocess import call

from urllib.parse import urljoin

import settings

from django.db import models
from django.core.files.storage import FileSystemStorage
from django.contrib.auth.models import User
from django.contrib.contenttypes.models import ContentType
from django.db.models import Min, Max
from django.conf import settings
from django.core.urlresolvers import reverse
from django.template import Context, loader

from troggle.core.models import *
from troggle.core.models_survex import *

class Area(TroggleModel):
    short_name = models.CharField(max_length=100)
    name = models.CharField(max_length=200, blank=True, null=True)
    description = models.TextField(blank=True,null=True)
    parent = models.ForeignKey('Area', blank=True, null=True)
    def __str__(self):
        if self.parent:
            return str(self.parent) + " - " + str(self.short_name)
        else:
            return str(self.short_name)
    def kat_area(self):
        if self.short_name in ["1623", "1626"]:
            return self.short_name
        elif self.parent:
            return self.parent.kat_area()

class CaveAndEntrance(models.Model):
    cave = models.ForeignKey('Cave')
    entrance = models.ForeignKey('Entrance')
    entrance_letter = models.CharField(max_length=20,blank=True,null=True)
    def __str__(self):
        return str(self.cave) + str(self.entrance_letter)
        
class CaveSlug(models.Model):
    cave = models.ForeignKey('Cave')
    slug = models.SlugField(max_length=50, unique = True)
    primary = models.BooleanField(default=False)

class Cave(TroggleModel):
    # too much here perhaps, 
    official_name = models.CharField(max_length=160)
    area = models.ManyToManyField(Area, blank=True, null=True)
    kataster_code = models.CharField(max_length=20,blank=True,null=True)
    kataster_number = models.CharField(max_length=10,blank=True, null=True)
    unofficial_number = models.CharField(max_length=60,blank=True, null=True)
    entrances = models.ManyToManyField('Entrance', through='CaveAndEntrance')
    explorers = models.TextField(blank=True,null=True)
    underground_description = models.TextField(blank=True,null=True)
    equipment = models.TextField(blank=True,null=True)
    references = models.TextField(blank=True,null=True)
    survey = models.TextField(blank=True,null=True)
    kataster_status = models.TextField(blank=True,null=True)
    underground_centre_line = models.TextField(blank=True,null=True)
    notes = models.TextField(blank=True,null=True)
    length = models.CharField(max_length=100,blank=True,null=True)
    depth = models.CharField(max_length=100,blank=True,null=True)
    extent = models.CharField(max_length=100,blank=True,null=True)
    survex_file = models.CharField(max_length=100,blank=True,null=True)
    description_file = models.CharField(max_length=200,blank=True,null=True)
    url = models.CharField(max_length=200,blank=True,null=True)
    filename = models.CharField(max_length=200)

    #class Meta:
    #    unique_together = (("area", "kataster_number"), ("area", "unofficial_number"))
    # FIXME Kataster Areas and CUCC defined sub areas need seperating    

    #href    = models.CharField(max_length=100)
    
    class Meta:
        ordering = ('kataster_code', 'unofficial_number')  

    def hassurvey(self):
        if not self.underground_centre_line:
            return "No"
        if (self.survey.find("<img") > -1 or self.survey.find("<a") > -1 or self.survey.find("<IMG") > -1 or self.survey.find("<A") > -1):
            return "Yes"
        return "Missing"

    def hassurveydata(self):
        if not self.underground_centre_line:
            return "No"
        if self.survex_file:
            return "Yes"
        return "Missing"
         
    def slug(self):
        primarySlugs = self.caveslug_set.filter(primary = True)
        if primarySlugs:
            return primarySlugs[0].slug
        else:
            slugs = self.caveslug_set.filter()
            if slugs:
                return slugs[0].slug

    def ours(self):
        return bool(re.search(r'CUCC', self.explorers))

    def reference(self):
        if self.kataster_number:
            return "%s-%s" % (self.kat_area(), self.kataster_number)
        else:
            return "%s-%s" % (self.kat_area(), self.unofficial_number)
    
    def get_absolute_url(self):
        if self.kataster_number:
            href = self.kataster_number
        elif self.unofficial_number:
            href = self.unofficial_number
        else:
            href = self.official_name.lower()
        #return settings.URL_ROOT + '/cave/' + href + '/'
        return urllib.parse.urljoin(settings.URL_ROOT, reverse('cave',kwargs={'cave_id':href,}))

    def __str__(self, sep = ": "):
        return str("slug:"+self.slug())

    def get_QMs(self):
        return QM.objects.filter(found_by__cave_slug=self.caveslug_set.all())	

    def new_QM_number(self, year=datetime.date.today().year):
            """Given a cave and the current year, returns the next QM number."""
            try:
                res=QM.objects.filter(found_by__date__year=year, found_by__cave=self).order_by('-number')[0]
            except IndexError:
                return 1
            return res.number+1

    def kat_area(self):
        for a in self.area.all():
            if a.kat_area():
                return a.kat_area()
    
    def entrances(self):
        return CaveAndEntrance.objects.filter(cave=self)

    def singleentrance(self):
        return len(CaveAndEntrance.objects.filter(cave=self)) == 1
    
    def entrancelist(self):
        rs = []
        res = ""
        for e in CaveAndEntrance.objects.filter(cave=self):
            rs.append(e.entrance_letter)
        rs.sort()
        prevR = None
        n = 0
        for r in rs:
            if prevR:
                if chr(ord(prevR) + 1 ) == r:
                    prevR = r
                    n += 1
                else:
                    if n == 0:
                        res += ", " + prevR
                    else:
                        res += "&ndash;" + prevR
            else:
                prevR = r
                n = 0
                res += r
        if n == 0:
            res += ", " + prevR
        else:
            res += "&ndash;" + prevR
        return res
    
    def writeDataFile(self):
        try:
            f = open(os.path.join(settings.CAVEDESCRIPTIONS, self.filename), "wb")
        except:
            subprocess.call(settings.FIX_PERMISSIONS) 
            f = open(os.path.join(settings.CAVEDESCRIPTIONS, self.filename), "wb")
        t = loader.get_template('dataformat/cave.xml')
        c = Context({'cave': self})
        u = t.render(c)
        u8 = u.encode("utf-8")
        f.write(u8)
        f.close()
        
    def getArea(self):
        areas = self.area.all()
        lowestareas = list(areas)
        for area in areas:
            if area.parent in areas:
                try:
                    lowestareas.remove(area.parent)
                except:
                    pass
        return lowestareas[0]

def getCaveByReference(reference):
    areaname, code = reference.split("-", 1)
    #print(areaname, code)
    area = Area.objects.get(short_name = areaname)
    #print(area)
    foundCaves = list(Cave.objects.filter(area = area,  kataster_number = code).all()) + list(Cave.objects.filter(area = area,  unofficial_number = code).all())
    print((list(foundCaves)))
    if len(foundCaves) == 1:
        return foundCaves[0]
    else:
        return False

class OtherCaveName(TroggleModel):
    name = models.CharField(max_length=160)
    cave = models.ForeignKey(Cave)
    def __str__(self):
        return str(self.name)

class EntranceSlug(models.Model):
    entrance = models.ForeignKey('Entrance')
    slug = models.SlugField(max_length=50, unique = True)
    primary = models.BooleanField(default=False)

class Entrance(TroggleModel):
    name = models.CharField(max_length=100, blank=True,null=True)
    entrance_description = models.TextField(blank=True,null=True)
    explorers = models.TextField(blank=True,null=True)
    map_description = models.TextField(blank=True,null=True)
    location_description = models.TextField(blank=True,null=True)
    approach = models.TextField(blank=True,null=True)
    underground_description = models.TextField(blank=True,null=True)
    photo = models.TextField(blank=True,null=True)
    MARKING_CHOICES = (
        ('P', 'Paint'),
        ('P?', 'Paint (?)'),
        ('T', 'Tag'),
        ('T?', 'Tag (?)'),
        ('R', 'Needs Retag'),
        ('S', 'Spit'),
        ('S?', 'Spit (?)'),
        ('U', 'Unmarked'),
        ('?', 'Unknown'))
    marking = models.CharField(max_length=2, choices=MARKING_CHOICES)
    marking_comment = models.TextField(blank=True,null=True)
    FINDABLE_CHOICES = (
        ('?', 'To be confirmed ...'),
        ('S', 'Coordinates'),
        ('L', 'Lost'),
        ('R', 'Refindable'))
    findability = models.CharField(max_length=1, choices=FINDABLE_CHOICES, blank=True, null=True)
    findability_description = models.TextField(blank=True,null=True)
    alt = models.TextField(blank=True, null=True)
    northing = models.TextField(blank=True, null=True)
    easting = models.TextField(blank=True, null=True)
    tag_station = models.TextField(blank=True, null=True)
    exact_station = models.TextField(blank=True, null=True)
    other_station = models.TextField(blank=True, null=True)
    other_description = models.TextField(blank=True,null=True)
    bearings = models.TextField(blank=True,null=True)
    url = models.CharField(max_length=200,blank=True,null=True)
    filename = models.CharField(max_length=200)
    cached_primary_slug = models.CharField(max_length=200,blank=True,null=True)

    def __str__(self):
        return str(self.slug())

    def exact_location(self):
        return SurvexStation.objects.lookup(self.exact_station)
    def other_location(self):
        return SurvexStation.objects.lookup(self.other_station)


    def find_location(self):
        r = {'':  'To be entered ',
			 '?': 'To be confirmed:',
             'S': '',
             'L': 'Lost:',
             'R': 'Refindable:'}[self.findability]
        if self.tag_station:
            try:
                s = SurvexStation.objects.lookup(self.tag_station)
                return r + "%0.0fE %0.0fN %0.0fAlt" % (s.x, s.y, s.z)
            except:
                return r + "%s Tag Station not in dataset" % self.tag_station
        if self.exact_station:
            try:
                s = SurvexStation.objects.lookup(self.exact_station)
                return r + "%0.0fE %0.0fN %0.0fAlt" % (s.x, s.y, s.z)
            except:
                return r + "%s Exact Station not in dataset" % self.tag_station
        if self.other_station:
            try:
                s = SurvexStation.objects.lookup(self.other_station)
                return r + "%0.0fE %0.0fN %0.0fAlt %s" % (s.x, s.y, s.z, self.other_description)
            except:
                return r + "%s Other Station not in dataset" % self.tag_station
        if self.FINDABLE_CHOICES == "S":
            r += "ERROR, Entrance has been surveyed but has no survex point"
        if self.bearings:
            return r + self.bearings
        return r

    def best_station(self):
        if self.tag_station:
            return self.tag_station
        if self.exact_station:
            return self.exact_station
        if self.other_station:
            return self.other_station

    def has_photo(self):
        if self.photo:
            if (self.photo.find("<img") > -1 or self.photo.find("<a") > -1 or self.photo.find("<IMG") > -1 or self.photo.find("<A") > -1):
                return "Yes"
            else:
                return "Missing"
        else:
            return "No"

    def marking_val(self):
        for m in self.MARKING_CHOICES:
            if m[0] == self.marking:
                return m[1]
    def findability_val(self):
        for f in self.FINDABLE_CHOICES:
            if f[0] == self.findability:
                return f[1]
                
    def tag(self):
        return SurvexStation.objects.lookup(self.tag_station)
        
    def needs_surface_work(self):
        return self.findability != "S" or not self.has_photo or self.marking != "T"

    def get_absolute_url(self):
        
        ancestor_titles='/'.join([subcave.title for subcave in self.get_ancestors()])
        if ancestor_titles:
            res = '/'.join((self.get_root().cave.get_absolute_url(), ancestor_titles, self.title))
        
        else:
            res = '/'.join((self.get_root().cave.get_absolute_url(), self.title))
            
        return res

    def slug(self):
        if not self.cached_primary_slug:
            primarySlugs = self.entranceslug_set.filter(primary = True)
            if primarySlugs:    
                self.cached_primary_slug = primarySlugs[0].slug
                self.save()
            else:
                slugs = self.entranceslug_set.filter()
                if slugs:
                    self.cached_primary_slug = slugs[0].slug
                    self.save()
        return self.cached_primary_slug

    def writeDataFile(self):
        try:
            f = open(os.path.join(settings.ENTRANCEDESCRIPTIONS, self.filename), "w")
        except:
            subprocess.call(settings.FIX_PERMISSIONS) 
            f = open(os.path.join(settings.ENTRANCEDESCRIPTIONS, self.filename), "w")
        t = loader.get_template('dataformat/entrance.xml')
        c = Context({'entrance': self})
        u = t.render(c)
        u8 = u.encode("utf-8")
        f.write(u8)
        f.close()

class CaveDescription(TroggleModel):
    short_name = models.CharField(max_length=50, unique = True)
    long_name = models.CharField(max_length=200, blank=True, null=True)
    description = models.TextField(blank=True,null=True)
    linked_subcaves = models.ManyToManyField("NewSubCave", blank=True,null=True)
    linked_entrances = models.ManyToManyField("Entrance", blank=True,null=True)
    linked_qms = models.ManyToManyField("QM", blank=True,null=True)

    def __str__(self):
        if self.long_name:
            return str(self.long_name)
        else:
            return str(self.short_name)
    
    def get_absolute_url(self):
        return urllib.parse.urljoin(settings.URL_ROOT, reverse('cavedescription', args=(self.short_name,)))
    
    def save(self):
        """
        Overridden save method which stores wikilinks in text as links in database.
        """      
        TroggleModel.save()
        #super(CaveDescription, self).save() # fails in python 3.8, OK in python 3.5
        qm_list=get_related_by_wikilinks(self.description)
        for qm in qm_list:
            self.linked_qms.add(qm)
        TroggleModel.save() 
        #super(CaveDescription, self).save() # fails in python 3.8, OK in python 3.5

class NewSubCave(TroggleModel):
    name = models.CharField(max_length=200, unique = True)
    def __str__(self):
        return str(self.name)

class QM(TroggleModel):
    #based on qm.csv in trunk/expoweb/1623/204 which has the fields:
    #"Number","Grade","Area","Description","Page reference","Nearest station","Completion description","Comment"
    found_by = models.ForeignKey(LogbookEntry, related_name='QMs_found',blank=True, null=True )
    ticked_off_by = models.ForeignKey(LogbookEntry, related_name='QMs_ticked_off',null=True,blank=True)
    #cave = models.ForeignKey(Cave)
    #expedition = models.ForeignKey(Expedition)

    number = models.IntegerField(help_text="this is the sequential number in the year", )
    GRADE_CHOICES=(
    ('A', 'A: Large obvious lead'),
    ('B', 'B: Average lead'),
    ('C', 'C: Tight unpromising lead'),
    ('D', 'D: Dig'),
    ('X', 'X: Unclimbable aven')
    )
    grade = models.CharField(max_length=1, choices=GRADE_CHOICES)
    location_description = models.TextField(blank=True)
    nearest_station_description = models.CharField(max_length=400,null=True,blank=True)
    nearest_station_name = models.CharField(max_length=200,blank=True,null=True)
    nearest_station = models.ForeignKey(SurvexStation,null=True,blank=True)
    area = models.CharField(max_length=100,blank=True,null=True)
    completion_description = models.TextField(blank=True,null=True)
    comment=models.TextField(blank=True,null=True)

    def __str__(self):
        return "%s %s" % (self.code(), self.grade)

    def code(self):
        return "%s-%s-%s" % (str(self.found_by.cave)[6:], self.found_by.date.year, self.number)

    def get_absolute_url(self):
        #return settings.URL_ROOT + '/cave/' + self.found_by.cave.kataster_number + '/' + str(self.found_by.date.year) + '-' + '%02d' %self.number
        return urllib.parse.urljoin(settings.URL_ROOT, reverse('qm',kwargs={'cave_id':self.found_by.cave.kataster_number,'year':self.found_by.date.year,'qm_id':self.number,'grade':self.grade}))

    def get_next_by_id(self):
        return QM.objects.get(id=self.id+1)

    def get_previous_by_id(self):
        return QM.objects.get(id=self.id-1)

    def wiki_link(self):
        return "%s%s%s" % ('[[QM:',self.code(),']]')

scansFileStorage = FileSystemStorage(location=settings.SURVEY_SCANS, base_url=settings.SURVEYS_URL)
def get_scan_path(instance, filename):
    year=instance.survey.expedition.year
    #print("WN: ", type(instance.survey.wallet_number), instance.survey.wallet_number, instance.survey.wallet_letter)
    number=str(instance.survey.wallet_number)
    if str(instance.survey.wallet_letter) != "None":
        number=str(instance.survey.wallet_letter) + number #two strings formatting because convention is 2009#01 or 2009#X01
    return os.path.join('./',year,year+r'#'+number,str(instance.contents)+str(instance.number_in_wallet)+r'.jpg')

class ScannedImage(TroggleImageModel): 
    file = models.ImageField(storage=scansFileStorage, upload_to=get_scan_path)
    scanned_by = models.ForeignKey(Person,blank=True, null=True)
    scanned_on = models.DateField(null=True)
    survey = models.ForeignKey('Survey')
    contents = models.CharField(max_length=20,choices=(('notes','notes'),('plan','plan_sketch'),('elevation','elevation_sketch')))
    number_in_wallet = models.IntegerField(null=True)
    lon_utm = models.FloatField(blank=True,null=True)
    lat_utm = models.FloatField(blank=True,null=True)

    #content_type = models.ForeignKey(ContentType)
    #object_id = models.PositiveIntegerField()
    #location = generic.GenericForeignKey('content_type', 'object_id')

    #This is an ugly hack to deal with the #s in our survey scan paths. The correct thing is to write a custom file storage backend which calls urlencode on the name for making file.url but not file.path.
    def correctURL(self):
        return string.replace(self.file.url,r'#',r'%23')

    def __str__(self):
        return get_scan_path(self,'')

class Survey(TroggleModel):
    expedition = models.ForeignKey('Expedition') #REDUNDANT (logbook_entry)
    wallet_number = models.IntegerField(blank=True,null=True)
    wallet_letter = models.CharField(max_length=1,blank=True,null=True)
    comments = models.TextField(blank=True,null=True)
    location = models.CharField(max_length=400,blank=True,null=True) #REDUNDANT
    subcave = models.ForeignKey('NewSubCave', blank=True, null=True)
    #notes_scan = models.ForeignKey('ScannedImage',related_name='notes_scan',blank=True, null=True)  	#Replaced by contents field of ScannedImage model
    survex_block  = models.OneToOneField('SurvexBlock',blank=True, null=True)
    logbook_entry = models.ForeignKey('LogbookEntry')
    centreline_printed_on = models.DateField(blank=True, null=True)
    centreline_printed_by = models.ForeignKey('Person',related_name='centreline_printed_by',blank=True,null=True)
    #sketch_scan = models.ForeignKey(ScannedImage,blank=True, null=True) 					#Replaced by contents field of ScannedImage model
    tunnel_file = models.FileField(upload_to='surveyXMLfiles',blank=True, null=True)
    tunnel_main_sketch = models.ForeignKey('Survey',blank=True,null=True)
    integrated_into_main_sketch_on = models.DateField(blank=True,null=True)
    integrated_into_main_sketch_by = models.ForeignKey('Person' ,related_name='integrated_into_main_sketch_by', blank=True,null=True)
    rendered_image = models.ImageField(upload_to='renderedSurveys',blank=True,null=True)
    def __str__(self):
        return self.expedition.year+"#"+"%02d" % int(self.wallet_number)

    def notes(self):
        return self.scannedimage_set.filter(contents='notes')

    def plans(self):
        return self.scannedimage_set.filter(contents='plan')

    def elevations(self):
        return self.scannedimage_set.filter(contents='elevation')