/* Copyright (C) 2011, 2012, 2013 by Bundesanstalt für Gewässerkunde
 * Software engineering by Intevation GmbH
 *
 * This file is Free Software under the GNU AGPL (>=v3)
 * and comes with ABSOLUTELY NO WARRANTY! Check out the
 * documentation coming with Dive4Elements River for details.
 */

package org.dive4elements.river.utils;

import org.dive4elements.artifacts.CallContext;
import org.dive4elements.river.artifacts.D4EArtifact;
import org.dive4elements.river.artifacts.access.RiverAccess;
import org.dive4elements.river.artifacts.model.LayerInfo;
import org.dive4elements.river.artifacts.model.map.WMSDBLayerFacet;
import org.dive4elements.river.artifacts.model.map.WMSLayerFacet;
import org.dive4elements.river.artifacts.model.map.WSPLGENLayerFacet;
import org.dive4elements.river.artifacts.resources.Resources;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.List;

import org.apache.log4j.Logger;
import org.apache.velocity.Template;
import org.geotools.data.shapefile.ShpFiles;
import org.geotools.data.shapefile.shp.ShapefileHeader;
import org.geotools.data.shapefile.shp.ShapefileReader;

public class ArtifactMapfileGenerator extends MapfileGenerator {

    private static Logger logger = Logger.getLogger(ArtifactMapfileGenerator.class);

    @Override
    protected String getVelocityLogfile() {
        return RiverUtils.getXPathString(RiverUtils.XPATH_FLOODMAP_VELOCITY_LOGFILE);
    }

    @Override
    protected String getMapserverTemplatePath() {
        return RiverUtils.getXPathString(RiverUtils.XPATH_FLOODMAP_MAPSERVER_TEMPLATE_PATH);
    }

    @Override
    public String getMapserverUrl() {
        return RiverUtils.getXPathString(RiverUtils.XPATH_FLOODMAP_MAPSERVER_URL);
    }

    /**
     * Method which starts searching for meta information file and mapfile
     * generation.
     */
    @Override
    public void generate() throws IOException
    {
        File[] userDirs = getUserDirs();
        List<String> layers = parseLayers(userDirs);
        logger.info("Found " + layers.size() + " layers for user mapfile.");

        writeMapfile(layers);
    }

    /**
     * Creates a layer file used for Mapserver's mapfile which represents the
     * floodmap.
     *
     * @param flys The D4EArtifact that owns <i>wms</i>.
     * @param wms The WMSLayerFacet that contains information for the layer.
     */
    public void createUeskLayer(
        D4EArtifact  flys,
        WSPLGENLayerFacet wms,
        String        style,
        CallContext context
    ) throws FileNotFoundException, IOException
    {
        logger.debug("createUeskLayer");

        LayerInfo layerinfo = new LayerInfo();
        layerinfo.setName(MS_WSPLGEN_PREFIX + flys.identifier());
        layerinfo.setType("POLYGON");
        layerinfo.setDirectory(flys.identifier());
        layerinfo.setData(WSPLGEN_RESULT_SHAPE);
        layerinfo.setTitle(Resources.getMsg(Resources.getLocale(context.getMeta()),
                                            "floodmap.uesk",
                                            "Floodmap"));
        layerinfo.setStyle(style);
        RiverAccess access = new RiverAccess(flys);
        String river = access.getRiver();
        layerinfo.setSrid(RiverUtils.getRiverDGMSrid(river));

        String name = MS_LAYER_PREFIX + wms.getName();

        Template template = getTemplateByName(WSPLGEN_LAYER_TEMPLATE);
        if (template == null) {
            logger.warn("Template '" + WSPLGEN_LAYER_TEMPLATE + "' found.");
            return;
        }

        try {
            File dir = new File(getShapefileBaseDir(), flys.identifier());
            writeLayer(layerinfo, new File(dir, name), template);
        }
        catch (FileNotFoundException fnfe) {
            logger.error(fnfe, fnfe);
            logger.warn("Unable to write layer: " + name);
        }
    }


    /**
     * Creates a layer file used for Mapserver's mapfile which represents the
     * shape files uploaded by the user.
     *
     * @param flys The D4EArtifact that owns <i>wms</i>.
     * @param wms The WMSLayerFacet that contains information for the layer.
     */
    public void createUserShapeLayer(D4EArtifact flys, WMSLayerFacet wms)
        throws FileNotFoundException, IOException
    {
        logger.debug("createUserShapeLayer");

        String uuid = flys.identifier();
        File   dir  = new File(getShapefileBaseDir(), uuid);
        File   test = new File(dir, WSPLGEN_USER_SHAPE);

        if (!test.exists() || !test.canRead()) {
            logger.debug("No user layer existing.");
            return;
        }

        File userShape = new File(dir, WSPLGEN_USER_SHAPE);
        ShpFiles sf = new ShpFiles(userShape);
        ShapefileReader sfr = new ShapefileReader(sf, true, false, null);
        ShapefileHeader sfh = sfr.getHeader();

        String group      = uuid + MS_USERSHAPE_PREFIX;
        String groupTitle = "I18N_USER_SHAPE_TITLE";

        LayerInfo info = new LayerInfo();
        info.setName(MS_USERSHAPE_PREFIX + uuid);
        if (sfh.getShapeType().isLineType()) {
            info.setType("LINE");
        }
        else if (sfh.getShapeType().isPolygonType()) {
            info.setType("POLYGON");
        }
        else {
            return;
        }
        info.setDirectory(uuid);
        info.setData(WSPLGEN_USER_SHAPE);
        info.setTitle("I18N_USER_SHAPE");
        info.setGroup(group);
        info.setGroupTitle(groupTitle);
        info.setSrid(wms.getSrid());

        String nameUser = MS_LAYER_PREFIX + wms.getName();

        Template tpl = getTemplateByName(SHP_LAYER_TEMPLATE);
        if (tpl == null) {
            logger.warn("Template '" + SHP_LAYER_TEMPLATE + "' found.");
            return;
        }

        try {
            writeLayer(info, new File(dir, nameUser), tpl);
        }
        catch (FileNotFoundException fnfe) {
            logger.error(fnfe, fnfe);
            logger.warn("Unable to write layer: " + nameUser);
        }

    }


    /**
     * Creates a layer file used for Mapserver's mapfile which represents
     * geometries from database.
     *
     * @param flys The D4EArtifact that owns <i>wms</i>.
     * @param wms The WMSLayerFacet that contains information for the layer.
     */
    public void createDatabaseLayer(
            D4EArtifact    flys,
            WMSDBLayerFacet wms,
            String          style
            )
        throws FileNotFoundException, IOException
    {
        logger.debug("createDatabaseLayer");

        LayerInfo layerinfo = new LayerInfo();
        layerinfo.setName(wms.getName() + "-" + flys.identifier());
        layerinfo.setType(wms.getGeometryType());
        layerinfo.setFilter(wms.getFilter());
        layerinfo.setData(wms.getData());
        layerinfo.setTitle(wms.getDescription());
        layerinfo.setStyle(style);
        if(wms.getExtent() != null) {
            layerinfo.setExtent(GeometryUtils.jtsBoundsToOLBounds(wms.getExtent()));
        }
        layerinfo.setConnection(wms.getConnection());
        layerinfo.setConnectionType(wms.getConnectionType());
        layerinfo.setLabelItem(wms.getLabelItem());
        layerinfo.setSrid(wms.getSrid());

        String name = MS_LAYER_PREFIX + wms.getName();

        Template template = getTemplateByName(DB_LAYER_TEMPLATE);
        if (template == null) {
            logger.warn("Template '" + DB_LAYER_TEMPLATE + "' found.");
            return;
        }

        try {
            File dir = new File(getShapefileBaseDir(), flys.identifier());
            writeLayer(layerinfo, new File(dir, name), template);
        }
        catch (FileNotFoundException fnfe) {
            logger.error(fnfe, fnfe);
            logger.warn("Unable to write layer: " + name);
        }
    }

    @Override
        protected String getMapfilePath() {
            return RiverUtils.getXPathString(RiverUtils.XPATH_FLOODMAP_MAPFILE_PATH);
        }

    @Override
        protected String getMapfileTemplate() {
            return RiverUtils.getXPathString(RiverUtils.XPATH_FLOODMAP_MAPFILE_TEMPLATE);
        }

}