import json

import os

import targets

from kml import *

class Config:

    class Value:

        def __init__(self, key, val):

            self.key = key

            self.val = val

            self.chk = True

            self.keyact = key + '_actual'

        def extract(self, p):

            if self.key in p:

                self.val = p[self.key][0]

            self.chk = True

    class ValueN(Value):

        def extract(self, p):

            if self.key in p:

                try:

                    self.val = float(p[self.key][0])

                    self.chk = True

                except:

                    self.val = p[self.key][0]

                    self.chk = False

    def __init__(self):

        # -------------------------------------------------

        # zadání - vstupní veličiny

        # -------------------------------------------------

        self.name = self.Value('NA', 'flyby')

        self.targname = self.Value('TA', '')

        self.lat = self.ValueN('LA', targets.Stalin.lat)

        self.long = self.ValueN('LO', targets.Stalin.long)

        self.h0 = self.ValueN('H0', 300)

        self.x0 = self.ValueN('X0', 8000)

        self.y0 = self.ValueN('Y0', -12000)

        self.z0 = self.ValueN('Z0', 12000)

        self.x1 = self.ValueN('X1', 0)

        self.y1 = self.ValueN('Y1', -150)

        self.z1 = self.ValueN('Z1', 100)

        self.exp = self.ValueN('EX', 2)

        self.steps = self.ValueN('ST', 600)

        self.speedfact = self.ValueN('SPF', 1)

        self.slowdown = self.Value('SLD', 'tangential')

        self.slowdfact = self.ValueN('SLF', 1)

        self.flyby = self.ValueN('FL', 1)

        self.influentials = ['name', 'targname', 'lat', 'long', 'h0', 'x0', 'y0', 'z0',

                       'x1', 'y1', 'z1', 'exp', 'steps', 'speedfact', 'slowdown', 'slowdfact', 'flyby']

        # -------------------------------------------------

        # počáteční podmínky

        # -------------------------------------------------

        self.dXmin = 0.1            # min delta X při numerické konvergenci

        self.minZ = 60				# minimální přípustná výška nad terénem v metrech

        self.dHmax = 5				# empirické maximální přípustné otočení pohledu v jednom kroku ve stupních

        self.durOpt = 23			# empirické optimum: rychlost otáčení pohledu = 23°/sec

        self.stepsMax = 9999

        # -------------------------------------------------

        # provozní konstanty

        # -------------------------------------------------

        self.configsrv = 'kml'

        self.dnldsrv = 'flyby'

        if 'HTTP_HOST' in os.environ:

            h = os.environ['HTTP_HOST'].split('.')

            self.srvhost = h[0].lower()

            self.srvdomain = '.'.join(h[1:])

            self.dnldqual = '.'.join((self.dnldsrv, self.srvdomain))

            self.configqual = '.'.join((self.configsrv, self.srvdomain))

            _reqPath = os.environ['HTTP_HOST'] + os.environ['REQUEST_URI'].split('?')[0]

            _configKeyWord = 'kml'

            _dnldKeyWord = 'flyby'

            self.configReq = _reqPath.lower().find(_configKeyWord) > -1

            self.dnldReq = _reqPath.lower().find(_dnldKeyWord) > -1

            _reqUrl = '{scheme}://{host}:{port}{path}'.\

                format(scheme=os.environ['REQUEST_SCHEME'],

                       host=os.environ['HTTP_HOST'],

                       port=os.environ['SERVER_PORT'],

                       path=os.environ['REQUEST_URI'].split('?')[0])

            self.dnldUrl = _reqUrl.lower().replace(_configKeyWord, _dnldKeyWord)

            deb('self.dnldUrl=%s' % self.dnldUrl)

            self.dnldPath = _reqPath.lower().replace(_configKeyWord, _dnldKeyWord)

            deb('self.dnldPath=%s' % self.dnldPath)

        self.defaultlat = 50.1

        self.defaultlong = 14.3

        self.parmsdir = 'params'

        self.targsdir = 'targets'

        self.kmlfn = 'flyby'		# jméno výstupu - neměnné

        self.zipped = False

        # zipping se nedá v současnosti používat, protože Google Earth se s ním nechová standardně

        # - viz .../memo/googleearth

        self.kmlfile = '{}.{}'.format(self.kmlfn, 'kmz' if self.zipped else 'kml')

        self.urlfile = 'url.kml'

        self.msg = ''

        self.flagged = False

    def adjust(self):

        self.x0.val = fabs(self.x0.val)

        if self.x0.val < self.dXmin:

            self.x0.val = 0

        self.x1.val = 0

        if self.z0.val < self.minZ:

            self.z0.val = self.minZ

        if self.z1.val < self.minZ:

            self.z1.val = self.minZ

        self.steps.val = int(round(self.steps.val))

        if self.steps.val <= 0:

            self.steps.val = 20

        if self.steps.val > self.stepsMax:

            self.steps.val = self.stepsMax

        self.exp.val = fabs(self.exp.val)

        self.flyby.val = int(fabs(self.flyby.val))

        if self.x0.val > 0:

            self.r0 = degrees(atan(self.y0.val / self.x0.val))				# lokální azimut na startu

            self.r1 = 90 if self.y1.val < 0 else -90						# lokální azimut v průletu

            if self.y1.val == 0:

                if self.y0.val == 0:

                    self.r1 = 90

                else:

                    self.r1 = 90 * fabs(self.y0.val) / self.y0.val

                    if self.exp.val <= 1:

                        self.r1 = -self.r1

            self.h1 = can360(self.h0.val + self.r0 + self.r1)				# azimut v průletu

            self.h2 = can360(self.h0.val + 2 * (self.h1 - self.h0.val))		# azimut na konci

        dY = self.y1.val - self.y0.val

        dZ = self.z1.val - self.z0.val

        if dY == 0:

            self.A = pi / 2 if dZ < 0 else -pi / 2

        else:

            self.A = atan(dZ / dY)											# sklon roviny letu, horiz = 0

            if dY > 0:

                self.A = self.A + pi if dZ <= 0 else self.A - pi

        F = sqrt(pow(dY, 2) + pow(dZ, 2))									# maximální funkční hodnota

        if self.x0.val > 0:

            self.K = F / pow(self.x0.val, self.exp.val)		# koeficient paraboly

        sa = SpeedAdjust(self.speedfact.val, self.slowdfact.val, self.steps.val, self)

        self.speedAdjust = sa.slowdowns[self.slowdown.val](sa)

        self.lastH = self.h0.val

        self.lastX, self.lastY, self.lastZ = self.x0.val, self.y0.val, self.z0.val

        self.dX = -2 * self.x0.val / self.steps.val

        if fabs(self.dX) < self.dXmin:

            self.dX = -self.dXmin

        self.sumSteps, self.sumDur = 0, 0

        self.rr = []

    def update_influentials(self, p):

        for n in self.influentials:

            v = eval('self.{}'.format(n))

            v.extract(p)

            self.flagged += (not v.chk)

        v = self.lat

        if v.chk:

            v.chk = (v.val >= -90 and v.val <= 90)

        v = self.long

        if v.chk:

            v.chk = v.val >= -180 and v.val <= 180

        v = self.slowdown

        v.chk = v.val in SpeedAdjust.keys

        self.flagged = False

        for n in self.influentials:

            v = eval('self.{}'.format(n))

            self.flagged += (not v.chk)

    def parmspath(self):

        return os.path.join(self.parmsdir, self.name.val)

    def parmsls(self):

        l = os.listdir(self.parmsdir)

        l.sort()

        #deb("l={}".format(l))

        return l

    def targspath(self, name):

        return os.path.join(self.targsdir, name)

    def targsls(self):

        l = os.listdir(self.targsdir)

        l.sort()

        return l

    def gettarget(self, name):

        fn = name if name != '' else 'point'

        path = self.targspath(fn)

        long = self.defaultlong

        lat = self.defaultlat

        if os.path.exists(path):

            g = {}

            for p in open(path).read().split(','):

                k, v = p.split('=')

                g[k] = v

            if self.long.key in g:

                long = g[self.long.key]

            if self.lat.key in g:

                lat = g[self.lat.key]

        return long, lat

    def storetarget(self, name, long, lat):

        fn = name if name != '' else 'point'

        path = self.targspath(fn)

        open(path, mode='w').write('{}={},{}={}'.format(self.lat.key, lat, self.long.key, long))

    def restoreparms(self):

        if not os.path.exists(self.parmspath()):

            return

        parms = dict(json.load(open(self.parmspath())))

        # for p in open(self.parmspath()).read().split(','):

        #     k,v = p.split('=')

        #     parms[k] = [v]

        self.update_influentials(parms)

    def storeparms(self):

        if not self.name:

            return

        # s = []

        p = {}

        for n in self.influentials:

            v = eval('self.{}'.format(n))

            # s = s + ['='.join((v.key,str(v.val)))]

            p[v.key] = [str(v.val)]

        # open(self.parmspath(), mode='w').write(','.join(s))

        json.dump(p, open(self.parmspath(), mode='w'), ensure_ascii=False)

    def printparms(self):

        s = []

        for n in self.influentials:

            v = eval('self.{}'.format(n))

            s = s + ['{}={}'.format(v.key, v.val)]

        return '\n'.join(s)

    def adjustenv(self):

        p = {}

        for k in os.environ:

            p[k] = [os.environ[k]]

        return p