#!/usr/bin/env python3
# -*- coding: utf8 -*-
import math


def dec_to_maptiles(lat_deg, lon_deg, zoom):
    lat_rad = math.radians(lat_deg)
    n = 2.0 ** zoom
    xtile = int((lon_deg + 180.0) / 360.0 * n)
    ytile = int((1.0 - math.log(math.tan(lat_rad) + (1 / math.cos(lat_rad))) / math.pi) / 2.0 * n)
    return xtile, ytile


def maptiles_to_dec(xtile, ytile, zoom):
    n = 2.0 ** zoom
    lon_dec = xtile / n * 360.0 - 180.0
    lat_rad = math.atan(math.sinh(math.pi * (1 - 2 * ytile / n)))
    lat_dec = math.degrees(lat_rad)
    return lat_dec, lon_dec


def dec_to_deg(lat_dec, lon_dec):  # Dezimalgrad in Dezimalminuten (Ausgabe als String)
    if lat_dec < 0:
        lat_pre = "S"
    else:
        lat_pre = "N"
    if lon_dec < 0:
        lon_pre = "W"
    else:
        lon_pre = "E"
    lat = abs(lat_dec)
    lon = abs(lon_dec)
    lat_degree = int(lat)
    lon_degree = int(lon)
    lat_minutes = (lat - lat_degree) * 60
    lon_minutes = (lon - lon_degree) * 60
    return ("{}{} {} {}{} {}".format(lat_pre, lat_degree, round(lat_minutes, 3), lon_pre, lon_degree,
                                     round(lon_minutes, 3)))


# text="2248563 1378644"
# text="8783 5384"
# text="52.357780217032044 12.995710372924805"
# text="-41.85 -87.64999999999998"
text = "52.520803 13.4088653"
# https://tile.openstreetmap.org/19/281070/172330.png
hilfetext = """
Bei vielen Online-Kartendiensten wie Openstreetmap oder
Google-Maps erfolgt die Kartendarstellung über vorberechnete
"Kachel"-Grafikdateien, welche ein Adressierungssystem benötigen
damit je nach Koordinate und Zoomstufe auch der richtige 
Kartenausschnitt dargestellt und klar ist welche Kacheln daneben
darzustellen ist wird.Bei OSM ist eine solche Kachel eine
PNG-Grafik mit 256x256 Pixeln und je nach Zoomstufe ist eine
unterschiedliche Anzahl solcher Kacheln/Tiles notwendig
um die ganze Welt abzubilden. Da je Zoomstufe sich die Anzahl 
der benötigten Kacheln vervierfacht ist bei den meisten
Diensten bei Zoomlevel 18 Schluß, OSM geht bis Zoomlevel 19.
Um die einzelnen Kacheln beim tilemap-Server abzufragen brauch
man die Zoomstufe, einen X und einen Y-Wert wobei dies alles
ganzahlige Werte sind.
Aufgerufen von den Servern werden die Kacheln dann nach dem
Muster http://servername/Zoom/X/Y.png
Den Fernsehturm mit Zoomstufe 18 findet man z.B. bei Openstreetmap
hier: https://tile.openstreetmap.org/18/140836/85970.png

Die Funktion arbeitet hier auf die Art und Weise, daß man 2 durch
ein Freizeichen getrennte Zahlen eingibt. 
Handelt es sich bei den angegebenen Zahlen um "Kommazahlen" welche
allerdings mit Punkt anzugeben sind (Bsp: 52.520803 13.4088653 ) 
geht die Funktion davon aus, daß es sich um Koordinaten in Dezimalgrad
handelt und sofern es gültige Koordinaten sind erfolgt eine Ausgabe
der X und Y Werte für die Zoomstufen und 1-25.
(Positive Zahlen stehen für Nord und Ost, negative für Süd und West)

Handelt es sich bei den beiden Zahlen um Ganzzahlen wird davon
ausgegangen, daß es sich um X und Y Werte handelt und es werde für
alle Zoomstufen von 1-25 Koordinaten in Dezimalminuten und
Dezimalgrad ausgegeben, sofern dies sinnvolle Koordinaten ergibt.
"""

text = text.split()
if "." in text[0] and len(text) == 2:
    print("DEC -> Maptiles")
    for zoom in range(1, 26):
        try:
            la = float(text[0])
            lo = float(text[1])
            if not la < -180 and not la > 180 and not lo < -180 and not lo > 180:
                x, y = dec_to_maptiles(la, lo, zoom)
                print("Zoom:{}  X:{} \tY:{}".format(zoom, x, y))
        except:
            pass
elif len(text) == 2:
    print("Maptiles->DEG,DEC")
    for zoom in range(1, 26):
        try:
            la, lo = maptiles_to_dec(int(text[0]), int(text[1]), zoom)
            if not la < -180 and not la > 180 and not lo < -180 and not lo > 180:
                print("Zoom: {} \tDEG: {} \tDEC: {} {}".format(zoom, dec_to_deg(la, lo), round(la, 5), round(lo, 5)))
        except:
            pass
else:
    print("Zahlen konnten nicht ermittelt werden!")