#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import sys
import tempfile

from nose.tools import eq_, raises

import mapnik

from .utilities import execution_path, run_all

PYTHON3 = sys.version_info[0] == 3


def setup():
    # All of the paths used are relative, if we run the tests
    # from another directory we need to chdir()
    os.chdir(execution_path('.'))


def test_simplest_render():
    m = mapnik.Map(256, 256)
    im = mapnik.Image(m.width, m.height)
    eq_(im.painted(), False)
    eq_(im.is_solid(), True)
    mapnik.render(m, im)
    eq_(im.painted(), False)
    eq_(im.is_solid(), True)
    s = im.tostring()
    if PYTHON3:
        eq_(s, 256 * 256 * b'\x00\x00\x00\x00')
    else:
        eq_(s, 256 * 256 * '\x00\x00\x00\x00')


def test_render_image_to_string():
    im = mapnik.Image(256, 256)
    im.fill(mapnik.Color('black'))
    eq_(im.painted(), False)
    eq_(im.is_solid(), True)
    s = im.tostring()
    if PYTHON3:
        eq_(s, 256 * 256 * b'\x00\x00\x00\xff')
    else:
        eq_(s, 256 * 256 * '\x00\x00\x00\xff')


def test_non_solid_image():
    im = mapnik.Image(256, 256)
    im.fill(mapnik.Color('black'))
    eq_(im.painted(), False)
    eq_(im.is_solid(), True)
    # set one pixel to a different color
    im.set_pixel(0, 0, mapnik.Color('white'))
    eq_(im.painted(), False)
    eq_(im.is_solid(), False)


def test_non_solid_image_view():
    im = mapnik.Image(256, 256)
    im.fill(mapnik.Color('black'))
    view = im.view(0, 0, 256, 256)
    eq_(view.is_solid(), True)
    # set one pixel to a different color
    im.set_pixel(0, 0, mapnik.Color('white'))
    eq_(im.is_solid(), False)
    # view, since it is the exact dimensions of the image
    # should also be non-solid
    eq_(view.is_solid(), False)
    # but not a view that excludes the single diff pixel
    view2 = im.view(1, 1, 256, 256)
    eq_(view2.is_solid(), True)


def test_setting_alpha():
    w, h = 256, 256
    im1 = mapnik.Image(w, h)
    # white, half transparent
    c1 = mapnik.Color('rgba(255,255,255,.5)')
    im1.fill(c1)
    eq_(im1.painted(), False)
    eq_(im1.is_solid(), True)
    # pure white
    im2 = mapnik.Image(w, h)
    c2 = mapnik.Color('rgba(255,255,255,1)')
    im2.fill(c2)
    im2.apply_opacity(c1.a / 255.0)
    eq_(im2.painted(), False)
    eq_(im2.is_solid(), True)
    eq_(len(im1.tostring('png32')), len(im2.tostring('png32')))


def test_render_image_to_file():
    im = mapnik.Image(256, 256)
    im.fill(mapnik.Color('black'))
    if mapnik.has_jpeg():
        im.save('test.jpg')
    im.save('test.png', 'png')
    if os.path.exists('test.jpg'):
        os.remove('test.jpg')
    else:
        return False
    if os.path.exists('test.png'):
        os.remove('test.png')
    else:
        return False


def get_paired_images(w, h, mapfile):
    tmp_map = 'tmp_map.xml'
    m = mapnik.Map(w, h)
    mapnik.load_map(m, mapfile)
    im = mapnik.Image(w, h)
    m.zoom_all()
    mapnik.render(m, im)
    mapnik.save_map(m, tmp_map)
    m2 = mapnik.Map(w, h)
    mapnik.load_map(m2, tmp_map)
    im2 = mapnik.Image(w, h)
    m2.zoom_all()
    mapnik.render(m2, im2)
    os.remove(tmp_map)
    return im, im2


def test_render_from_serialization():
    try:
        im, im2 = get_paired_images(
            100, 100, '../data/good_maps/building_symbolizer.xml')
        eq_(im.tostring('png32'), im2.tostring('png32'))

        im, im2 = get_paired_images(
            100, 100, '../data/good_maps/polygon_symbolizer.xml')
        eq_(im.tostring('png32'), im2.tostring('png32'))
    except RuntimeError as e:
        # only test datasources that we have installed
        if not 'Could not create datasource' in str(e):
            raise RuntimeError(e)


def test_render_points():
    if not mapnik.has_cairo():
        return
    # create and populate point datasource (WGS84 lat-lon coordinates)
    ds = mapnik.MemoryDatasource()
    context = mapnik.Context()
    context.push('Name')
    f = mapnik.Feature(context, 1)
    f['Name'] = 'Westernmost Point'
    f.geometry = mapnik.Geometry.from_wkt('POINT (142.48 -38.38)')
    ds.add_feature(f)

    f = mapnik.Feature(context, 2)
    f['Name'] = 'Southernmost Point'
    f.geometry = mapnik.Geometry.from_wkt('POINT (143.10 -38.60)')
    ds.add_feature(f)

    # create layer/rule/style
    s = mapnik.Style()
    r = mapnik.Rule()
    symb = mapnik.PointSymbolizer()
    symb.allow_overlap = True
    r.symbols.append(symb)
    s.rules.append(r)
    lyr = mapnik.Layer(
        'Places',
        '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
    lyr.datasource = ds
    lyr.styles.append('places_labels')
    # latlon bounding box corners
    ul_lonlat = mapnik.Coord(142.30, -38.20)
    lr_lonlat = mapnik.Coord(143.40, -38.80)
    # render for different projections
    projs = {
        'google': '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs +over',
        'latlon': '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs',
        'merc': '+proj=merc +datum=WGS84 +k=1.0 +units=m +over +no_defs',
        'utm': '+proj=utm +zone=54 +datum=WGS84'
    }
    for projdescr in projs:
        m = mapnik.Map(1000, 500, projs[projdescr])
        m.append_style('places_labels', s)
        m.layers.append(lyr)
        dest_proj = mapnik.Projection(projs[projdescr])
        src_proj = mapnik.Projection('+init=epsg:4326')
        tr = mapnik.ProjTransform(src_proj, dest_proj)
        m.zoom_to_box(tr.forward(mapnik.Box2d(ul_lonlat, lr_lonlat)))
        # Render to SVG so that it can be checked how many points are there
        # with string comparison
        svg_file = os.path.join(
            tempfile.gettempdir(),
            'mapnik-render-points-%s.svg' %
            projdescr)
        mapnik.render_to_file(m, svg_file)
        num_points_present = len(list(ds.all_features()))
        with open(svg_file, 'r') as f:
            svg = f.read()
        num_points_rendered = svg.count('<image ')
        eq_(
            num_points_present,
            num_points_rendered,
            "Not all points were rendered (%d instead of %d) at projection %s" %
            (num_points_rendered,
             num_points_present,
             projdescr))


@raises(RuntimeError)
def test_render_with_scale_factor_zero_throws():
    m = mapnik.Map(256, 256)
    im = mapnik.Image(256, 256)
    mapnik.render(m, im, 0.0)


def test_render_with_detector():
    ds = mapnik.MemoryDatasource()
    context = mapnik.Context()
    geojson = '{ "type": "Feature", "geometry": { "type": "Point", "coordinates": [ 0, 0 ] } }'
    ds.add_feature(mapnik.Feature.from_geojson(geojson, context))
    s = mapnik.Style()
    r = mapnik.Rule()
    lyr = mapnik.Layer('point')
    lyr.datasource = ds
    lyr.styles.append('point')
    symb = mapnik.MarkersSymbolizer()
    symb.allow_overlap = False
    r.symbols.append(symb)
    s.rules.append(r)
    m = mapnik.Map(256, 256)
    m.append_style('point', s)
    m.layers.append(lyr)
    m.zoom_to_box(mapnik.Box2d(-180, -85, 180, 85))
    im = mapnik.Image(256, 256)
    mapnik.render(m, im)
    expected_file = './images/support/marker-in-center.png'
    actual_file = '/tmp/' + os.path.basename(expected_file)
    # im.save(expected_file,'png8')
    im.save(actual_file, 'png8')
    actual = mapnik.Image.open(expected_file)
    expected = mapnik.Image.open(expected_file)
    eq_(actual.tostring('png32'),
        expected.tostring('png32'),
        'failed comparing actual (%s) and expected (%s)' % (actual_file,
                                                            expected_file))
    # now render will a collision detector that should
    # block out the placement of this point
    detector = mapnik.LabelCollisionDetector(m)
    eq_(detector.extent(), mapnik.Box2d(-0.0, -0.0, m.width, m.height))
    eq_(detector.extent(), mapnik.Box2d(-0.0, -0.0, 256.0, 256.0))
    eq_(detector.boxes(), [])
    detector.insert(detector.extent())
    eq_(detector.boxes(), [detector.extent()])
    im2 = mapnik.Image(256, 256)
    mapnik.render_with_detector(m, im2, detector)
    expected_file_collision = './images/support/marker-in-center-not-placed.png'
    # im2.save(expected_file_collision,'png8')
    actual_file = '/tmp/' + os.path.basename(expected_file_collision)
    im2.save(actual_file, 'png8')


if 'shape' in mapnik.DatasourceCache.plugin_names():

    def test_render_with_scale_factor():
        m = mapnik.Map(256, 256)
        mapnik.load_map(m, '../data/good_maps/marker-text-line.xml')
        m.zoom_all()
        sizes = [.00001, .005, .1, .899, 1, 1.5, 2, 5, 10, 100]
        for size in sizes:
            im = mapnik.Image(256, 256)
            mapnik.render(m, im, size)
            expected_file = './images/support/marker-text-line-scale-factor-%s.png' % size
            actual_file = '/tmp/' + os.path.basename(expected_file)
            im.save(actual_file, 'png32')
            if os.environ.get('UPDATE'):
                im.save(expected_file, 'png32')
            # we save and re-open here so both png8 images are ready as full
            # color png
            actual = mapnik.Image.open(actual_file)
            expected = mapnik.Image.open(expected_file)
            eq_(actual.tostring('png32'),
                expected.tostring('png32'),
                'failed comparing actual (%s) and expected (%s)' % (actual_file,
                                                                    expected_file))

if __name__ == "__main__":
    setup()
    exit(run_all(eval(x) for x in dir() if x.startswith("test_")))
