def test_fromstring_kml_document(self):
     "Tests the parsing of an valid KML string"
     test_kml = '<kml xmlns="http://www.opengis.net/kml/2.2"/>'
     tree = fromstring(test_kml, schema=Schema("ogckml22.xsd"))
     self.assertEquals(etree.tostring(tree), test_kml)
     tree = fromstring(test_kml)
     self.assertEquals(etree.tostring(tree), test_kml)

def load_sat_from_net():
    """
    Program to load the satllite track prediction from the internet
    Checks at the avdc website
    """
    from datetime import datetime,timedelta
    from urllib2 import urlopen
    from pykml import parser
    today = datetime.now().strftime('%Y%m%d')
    site = 'http://avdc.gsfc.nasa.gov/download_2.php?site=98675770&id=25&go=download&path=%2FSubsatellite%2Fkml&file=A-Train_subsatellite_prediction_'+today+'T000000Z.kml'
    print 'Satellite tracks url: %s' %site
    try:
        response = urlopen(site)
        print 'Getting the kml prediction file from avdc.gsfc.nasa.gov'
        r = response.read()
        kml = parser.fromstring(r)
    except:
        print 'Problem with day, trying previous day...'
        try:
            yesterday = (datetime.now()-timedelta(days=1)).strftime('%Y%m%d')
            site = 'http://avdc.gsfc.nasa.gov/download_2.php?site=98675770&id=25&go=download&path=%2FSubsatellite%2Fkml&file=A-Train_subsatellite_prediction_'+yesterday+'T000000Z.kml'
            response = urlopen(site)
            print 'Getting the kml prediction file from avdc.gsfc.nasa.gov'
            r = response.read()
            kml = parser.fromstring(r)
        except:
            import tkMessageBox
            tkMessageBox.showerror('No sat','There was an error communicating with avdc.gsfc.nasa.gov')
            return None
    print 'Kml file read...'
    return kml

 def test_fromstring_kml_document(self):
     """Tests the parsing of an valid KML string"""
     test_kml = b'<kml xmlns="http://www.opengis.net/kml/2.2"/>'
     tree = fromstring(test_kml, schema=Schema('ogckml22.xsd'))
     self.assertEqual(etree.tostring(tree, encoding='ascii'), test_kml)
     tree = fromstring(test_kml)
     self.assertEqual(etree.tostring(tree, encoding='ascii'), test_kml)

def parse_bcn_metro(basepath):
    files = ['TMB_EST.kml', 'TRAM_EST.kml']
    places = []
    for f in files:
        with open(basepath + f, 'rb') as x:
            xml = etree.parse(x)
        k = parser.fromstring(etree.tostring(xml))
        places.extend(k.findall('.//{http://www.opengis.net/kml/2.2}Placemark'))

    stations = []
    count = 0
    for p in places:
        station = { 'mode' : 'metro' }
        station['city'] = 'Barcelona'
        station['name'] = p.name.text

        coords = [float(c.strip()) for c in p.Point.coordinates.text.split(',')]

        # BCN inserts a trailing 0 coordinate? Why!?
        coords.pop()

        loc = { 'type' : 'Point' }
        loc['coordinates'] = coords
        station['loc'] = loc

        stations.append(station)

    return stations

def stop_read(filename):

    kmz = ZipFile(filename, 'r')
    files = kmz.namelist()
    # there must be just one file

    kmltext = kmz.open(files[0], 'r').read().decode('iso-8859-1')
    kmltext = kmltext.replace(' encoding="UTF-8"', '')

    k = parser.fromstring(kmltext)

    compania = k.Document.Folder[0]
    compania_nombre = compania.name

    coche = compania.Folder[0]
    coche_nombre = coche.name

    puntos = recuperar_paradas(coche)


    resultado = {
        'compania': compania_nombre,
        'coche': coche_nombre,
        'puntos': puntos
    }

    return resultado

def extract_tracks(f):
    from pykml import parser

    root = parser.fromstring(f.read())
    tracks = find_tracks(root.Document.Placemark)

    return tracks

 def loadKML( self, fileName ):
     """
     return a pykml object that is saved in the kml file fileName
     """
     with open( fileName, 'rb' ) as f:
         kml_str = f.read()
     return parser.fromstring( kml_str )

    def load_grid_from_file(self, kml_file):
        """ parse kml file and add grid to grid_cache """

        file = open(kml_file, "r")
        data = str.encode(file.read())

        root = parser.fromstring(data)
        pms = root.Document.Folder.Placemark

        for pm in pms:
            id = str(pm.ExtendedData.SchemaData.SimpleData[0])
            print(id)

            coords = None

            try:
                coords = pm.MultiGeometry.Polygon.outerBoundaryIs.LinearRing.coordinates
            except:
                try:
                    coords = pm.Polygon.outerBoundaryIs.LinearRing.coordinates
                except:
                    raise

            self.grid_cache[id] = Grid(id, parse_coords(str(coords)))

        print(len(self.grid_cache.keys()))

def parse_madrid_metro(basepath):
    files = ['Metro.kml', 'MetroLigero.kml']
    places = []
    for f in files:
        with open(basepath + f, 'rb') as x:
            xml = etree.parse(x)
        k = parser.fromstring(etree.tostring(xml))
        places.extend(k.findall('.//{http://www.opengis.net/kml/2.2}Placemark'))

    stations = []
    count = 0
    for p in places:
        station = { 'mode' : 'metro' }
        station['city'] = 'Madrid'
        station['name'] = p.name.text

        coords = [float(c.strip()) for c in p.Point.coordinates.text.split(',')]

        loc = { 'type' : 'Point' }
        loc['coordinates'] = coords
        station['loc'] = loc

        stations.append(station)

    return stations

def parse_london_metro(basepath):
    with open(basepath + 'stations.kml', 'rb') as x:
        xml = etree.parse(x)
    k = parser.fromstring(etree.tostring(xml))
    places = (k.findall('.//{http://www.opengis.net/kml/2.2}Placemark'))

    stations = []
    count = 0
    for p in places:
        station = { 'mode' : 'metro' }
        station['city'] = 'London'
        station['name'] = p.name.text.strip()

        coords = [float(c.strip()) for c in p.Point.coordinates.text.split(',')]

        # London inserts a trailing 0 coordinate too? Why!?
        coords.pop()

        loc = { 'type' : 'Point' }
        loc['coordinates'] = coords
        station['loc'] = loc

        stations.append(station)

    return stations

def load_kml_string(kml_string, schema_type = "kml22gx.xsd"):
    schema_gx = Schema(schema_type)
    doc = parser.fromstring(kml_string, schema_gx)
    
    if (schema_gx.validate(doc)):
        return doc
    else:
        print "Invalid kml format for string passed in"
        return None

def load_sat_from_file(filename):
    """
    Program to load the satellite track prediction from a saved file
    """
    from pykml import parser
    f = open(filename,'r')
    r = f.read()
    kml = parser.fromstring(r)
    return kml

 def test_fromstring_invalid_kml_document(self):
     "Tests the parsing of an invalid KML string"
     test_kml = '<bad_element />'
     try:
         tree = fromstring(test_kml, schema=Schema("ogckml22.xsd"))
         self.assertTrue(False)
     except etree.XMLSyntaxError:
         self.assertTrue(True)
     except:
         self.assertTrue(False)

    def openKML(self,kmlfile):
        if os.path.splitext(kmlfile)[1]=='.kmz':
            kmlfile     =zipfile.ZipFile(kmlfile)
            kmlfilename =kmlfile.namelist()[0]
            coordfile   =kmlfile.read(kmlfilename)
        else:
            coordfile   =open(kmlfile).read()

        self.kmlfile    =coordfile
        self.doc        =parser.fromstring(coordfile)

def __get_all_coords(data):
        doc = parser.fromstring(data) 
        coords = {}     
        for folder in doc.Document.getchildren():
            try:
               	dataPoints = folder.Placemark.LineString.coordinates.text.split(" ") 
                section_id = folder.Placemark.name.text
                coords[section_id] = [[float(i) for i in x.split(",")[:2]] for x in dataPoints]
            except (Exception):
                continue
        return coords

def validate_kml(filepath, schema = "https://developers.google.com/kml/schema/kml21.xsd"):
        """
        Validates kml located at filepath.
        TODO: Even imported kml files do not validate against default xml
        """
        schema_gomaps = Schema(schema)
	data = ""
	with open(filepath, "r") as temp:
		data = temp.read()
	assert(data != "")
	doc = parser.fromstring(data)
        return schema_ogc.assertValid(doc)

def retrieve_sites_info_awac_kml(kml_url=AWAC_KML_URL):
    """
    downloads a kml from dept_of_transport WA. retrieve informations to create a dictionary of site info(lat, lon, data url ...
    :param kml_url: string url kml to parse
    :return: dictionary
    """

    logger.info('Parsing {url}'.format(url=kml_url))
    try:
        fileobject = requests.get(kml_url).content
    except:
        logger.error('{url} not reachable. Retry'.format(url=kml_url))
        raise requests.ConnectionError

    root = kml_parser.fromstring(fileobject)
    doc = root.Document.Folder

    sites_info = dict()
    for pm in doc.Placemark:

        coordinates = pm.Point.coordinates.pyval
        latitude = float(coordinates.split(',')[1])
        longitude = float(coordinates.split(',')[0])
        water_depth = float(coordinates.split(',')[2])

        description = pm.description.text

        snippet = pm.snippet.pyval
        time_start = snippet.split(' - ')[0]
        time_end = snippet.split(' - ')[1]
        time_start = datetime.datetime.strptime(time_start, '%Y-%m-%d')
        time_end = datetime.datetime.strptime(time_end, '%Y-%m-%d')

        name = pm.name.text
        soup = BeautifulSoup(description)
        text_zip_url = soup.findAll('a', attrs={'href': re.compile("^http(s|)://.*_Text.zip")})[0].attrMap['href']

        m = re.search('<b>AWAC LOCATION ID:</b>(.*)<br>', description)
        site_code = m.group(1).lstrip()
        logger.info('{site} available for download'.format(site=site_code))
        site_info = {'site_name': name,
                     'lat_lon': [latitude, longitude],
                     'timezone': 8,
                     'latitude': latitude,
                     'longitude': longitude,
                     'water_depth': water_depth,
                     'time_start': time_start,
                     'time_end': time_end,
                     'text_zip_url': text_zip_url,
                     'site_code': site_code}
        sites_info[site_code] = site_info

    return sites_info

def handle_uploaded_kmlfile(filename,objectid):
    from pykml import parser
    from pykml.util import to_wkt_list
    
    # check if the file is too large
    if filename.size >= filename.DEFAULT_CHUNK_SIZE:
        raise IOError
    # parse the incoming file
    doc = parser.fromstring(filename.read())
    # look for geometries
    wkt_list = [{'geom':wkt} for wkt in to_wkt_list(doc)]
    
    return(wkt_list)

def load_route():
    try:
        data = json.loads(request.data)
        url = data['url']
    except Exception as e:
        logging.error(0)
        abort(400)

    obj = urllib2.urlopen(url)
    str = obj.read()
    kml_str = ""
    for line in iter(str.splitlines()):
        if not 'atom:link' in line:
            kml_str += line
            kml_str += '\n'

    Point.objects(type='route').delete()

    root = parser.fromstring(kml_str)

    pointid = 1000
    for placemark in root.Document.Folder.Placemark:
        coordinates = placemark.MultiGeometry.Point.coordinates.text.split(',')
        try:
            point = Point(
                title=placemark.name.text,
                type='route',
                latitude=float(coordinates[1]),
                longitude=float(coordinates[0]),
                pointid=pointid,
                timestamp=datetime.now()
            )
        except TypeError:
            abort(500)
        except Exception as e:
            logging.error(0)
            abort(500)
        try:
            point.save()
        except TypeError:
            abort(400)
        except BadRequest as e:
            logging.error(e)
            abort(400)
        except Exception as e:
            logging.error(e)
            abort(500)

        pointid += 1

    return Response(json.dumps({'status': 'ok'}), status=200, mimetype='application/json')

def parse_map_user(user):

    kml = os.path.join(os.getcwd(), 'data.kml')
    with open(kml) as f:
        doc = parser.fromstring(f.read())
        coords = doc.Document.Folder.Placemark.LineString.coordinates[0].text.strip().split()
        points = [(x.split(',')[0], x.split(',')[1]) for x in coords]

    for p in points:
        d = Data(0, 0, 0, p[1], p[0], datetime.now(), user)
        db.session.add(d)


    db.session.commit()