import sys

import xml.sax.saxutils

from math import *

class Kml():

    def __init__(self):

        self.out = sys.stdout

        self.placemark = Placemark(self)

        self.tour = Tour(self)

        self.playlist = Playlist(self)

        self.flyto = FlyTo(self)

        self.lookat = LookAt(self)

        self.camera = Camera(self)

        self.document = Document(self)

        self.folder = Folder(self)

        self.xml = Xml(self)

    def documentProlog(self, fn):

        self.xml.head()

        self.document.head(fn)

    def documentEpilog(self):

        self.document.tail()

        self.xml.tail()

    def folderProlog(self, fn):

        self.folder.head(fn)

    def folderEpilog(self):

        self.folder.tail()

    def tourProlog(self, fn):

        self.tour.head(fn)

        self.playlist.head()

    def tourEpilog(self):

        self.playlist.tail()

        self.tour.tail()

    def placemarkProlog(self, fn):

        self.xml.head()

        self.placemark.head(fn)

    def placemarkEpilog(self):

        self.placemark.tail()

        self.xml.tail()

    def urlPlacemark(self, url, path):

        # ref = '<a href="http://{}/index.py">{}</a>'.format(qualname, qualname)

        ref = '<a href="{}">{}</a>'.format(url, path)

        p = self.pr

        p('<Placemark>')

        p('<name>{ref}</name>'.format(ref = xml.sax.saxutils.escape(ref)))

        p('</Placemark>')

    def wait(self, dur):

        self.pr('\n<gx:Wait><gx:duration>{}</gx:duration></gx:Wait>'.format(dur))

    def comm(self, c):

        self.pr('\n<!-- {} -->'.format(c))

    def pr(self, s):

        print(s, file=self.out)

class Xml():

    def __init__(self, kml):

        self.kml = kml

    def head(self):

        self.kml.pr('<?xml version="1.0" encoding="UTF-8"?>')

        self.kml.pr('<kml')

        self.kml.pr('xmlns="http://www.opengis.net/kml/2.2"')

        self.kml.pr('xmlns:gx="http://www.google.com/kml/ext/2.2"')

        self.kml.pr('>')

    def tail(self):

        self.kml.pr('\n</kml>')

class Document():

    def __init__(self, kml):

        self.kml = kml

    def head(self, fn):

        self.kml.pr('<Document>')

        self.kml.pr('<name>{}</name>'.format(fn))

        self.kml.pr('<open>1</open>')

    def tail(self):

        self.kml.pr('\n</Document>')

class Folder():

    def __init__(self, kml):

        self.kml = kml

    def head(self, fn):

        self.kml.pr('<Folder>')

        self.kml.pr('<name>{}</name>'.format(fn))

        self.kml.pr('<open>1</open>')

    def tail(self):

        self.kml.pr('\n</Folder>')

class Tour():

    def __init__(self, kml):

        self.kml = kml

    def head(self, fn):

        self.kml.pr('\n<gx:Tour>')

        self.kml.pr('<name>{}</name>'.format(fn))

    def tail(self):

        self.kml.pr('\n</gx:Tour>')

class Playlist():

    def __init__(self, kml):

        self.kml = kml

    def head(self):

        self.kml.pr('\n<gx:Playlist>')

    def tail(self):

        self.kml.wait(1)

        self.kml.pr('\n</gx:Playlist>')

class FlyTo():

    def __init__(self, kml):

        self.kml = kml

    def head(self, dur, smooth):

        self.kml.pr('<gx:FlyTo>')

        self.kml.pr('<gx:duration>{}</gx:duration>'.format(dur))

        self.kml.pr('<gx:flyToMode>{}</gx:flyToMode>'.format('smooth' if smooth else 'bounce'))

    def tail(self):

        self.kml.pr('\n</gx:FlyTo>')

class LookAt():

    def __init__(self, kml):

        self.kml = kml

    def run(self, long,lat,alt,head,tilt,range):

        self.kml.pr('\n<LookAt>')

        self.kml.pr('<latitude>{}</latitude>'.format(lat))

        self.kml.pr('<longitude>{}</longitude>'.format(long))

        self.kml.pr('<altitude>{}</altitude>'.format(alt))

        self.kml.pr('<heading>{}</heading>'.format(head))

        self.kml.pr('<tilt>{}</tilt>'.format(tilt))

        self.kml.pr('<range>{}</range>'.format(range))

        self.kml.pr('<altitudeMode>relativeToGround</altitudeMode>')

        self.kml.pr('</LookAt>')

class Camera():

    def __init__(self, kml):

        self.kml = kml

    def run(self,long,lat,alt,head,tilt,roll):

        self.kml.pr('<Camera>')

        self.kml.pr('<latitude>{}</latitude>'.format(lat))

        self.kml.pr('<longitude>{}</longitude>'.format(long))

        self.kml.pr('<altitude>{}</altitude>'.format(alt))

        self.kml.pr('<heading>{}</heading>'.format(head))

        self.kml.pr('<tilt>{}</tilt>'.format(tilt))

        self.kml.pr('<roll>{}</roll>'.format(roll))

        self.kml.pr('<altitudeMode>relativeToSeaFloor</altitudeMode>')

        self.kml.pr('</Camera>')

    def runL(self, long, lat, alt, head, tilt, range, roll):

        # dostává parametry LookAt, které konvertuje na parametry Camera tak, aby pohled byl stejný

        dLO, dLA, Z = l2c(lat, head, tilt, range)

        self.run(long + dLO, lat + dLA, Z, head, tilt, roll)

class Placemark():

    def __init__(self, kml):

        self.kml = kml

    def head(self, fn):

        self.kml.pr('<Placemark>')

        self.kml.pr('<name>{}</name>'.format(fn))

        self.kml.pr('<visibility>0</visibility>')

        self.kml.pr('<styleUrl>#PIN_YELLOW</styleUrl>')

    def tail(self):

        self.kml.pr('\n</Placemark>')

class SpeedAdjust():

    keys = ['none', 'linear', 'parabolic', 'tangential', 'exponential']

    abrv = {'none':'none', 'linear':'lin', 'parabolic':'par', 'tangential':'tang', 'exponential':'exp'}

    def __init__(self, const, koef, steps, config):

        self.slowdowns = {'none':self.Const, 'linear':self.Linear, 'parabolic':self.Parabolic, 'tangential':self.Tangent, 'exponential':self.Exponential}

        self.const = const

        self.koef = koef

        self.steps = steps

        self.c = config

    def phase(self):

        return 1 - self.c.xi / self.c.x0.val

    class Const():

        p = 1					# empirická konstanta

        def __init__(self, sa):

            self.sa = sa

        def koef(self):

            return self.p / self.sa.const

    class Linear():

        p = 2					# empirická konstanta

        def __init__(self, sa):

            self.sa = sa

        def koef(self):

            return self.p * self.sa.koef * self.sa.phase() / self.sa.const

    class Parabolic():

        p = 2					# empirická konstanta

        def __init__(self, sa):

            self.sa = sa

        def koef(self):

            return self.p * pow(self.sa.koef * self.sa.phase(), 2) / self.sa.const

    class Tangent():

        p = 1					# empirická konstanta

        def __init__(self, sa):

            self.sa = sa

        def koef(self):

            margin = atan(self.sa.koef)		# < pi/2

            return (1 + self.p * tan(self.sa.phase() * margin)) / self.sa.const

    class Exponential():

        p = 1					# empirická konstanta

        def __init__(self, sa):

            self.sa = sa

        def koef(self):

            return pow(e, self.p * self.sa.koef * self.sa.phase()) / self.sa.const

def canonGeodetic(a):

    if(a > 360 or a < -360): a = a % 360

    if(a > 180): a = a - 360

    if(a < -180): a = a + 360

    return a

def can360(a360):

    if(a360 < 0): a360 = a360 + 360

    elif(a360 > 360): a360 = a360 - 360

    return a360

def can180(a180):

    if(a180 < -180): a180 = a180 + 360

    elif(a180 > 180): a180 = a180 - 360

    return a180

def l2c(lat, head, tilt, range):

    RZ = 6378000

    RL = RZ * cos(radians(lat))

    Hc = can360(head + 180)

    Z = range * cos(radians(tilt))

    d = sqrt(pow(range,2) - pow(Z,2))

    dLA = degrees(atan(d * cos(radians(Hc)) / RZ))

    dLO = degrees(atan(d * sin(radians(Hc)) / RL))

    return dLO, dLA, Z

def deb(s):

    print('+++ {}'.format(s), file=sys.stderr)