/**
 * Title:           Row, $Header: /share/gdi/SDI-Suite/Repository/projekte/BSH-GDI/genericViewer/src/main/java/de/conterra/bsh/gdi/gnviewer/datasources/Row.java,v 1.4 2008/01/30 12:38:34 blume Exp $
 * Source:          $Source: /share/gdi/SDI-Suite/Repository/projekte/BSH-GDI/genericViewer/src/main/java/de/conterra/bsh/gdi/gnviewer/datasources/Row.java,v $
 * created by:      Stefan Blume (blume)
 * erstellt am:     21.11.2007
 * Copyright:       con terra GmbH, 2005
 *
 * modified by:     $Author: blume $
 * modified on:     $Date: 2008/01/30 12:38:34 $
 * Version:         $Revision: 1.4 $
 * TAG:             $Name:  $
 * locked from:     $Locker:  $
 * CVS State:       $State: Exp $
 * Project:         $ProjectName$
 */
package de.intevation.gnv.geobackend.sde.datasources;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;

import org.apache.log4j.Logger;

import com.esri.sde.sdk.client.SDEPoint;
import com.esri.sde.sdk.client.SeException;
import com.esri.sde.sdk.client.SeShape;

import de.intevation.gnv.geobackend.sde.datasources.exception.TechnicalException;
import de.intevation.gnv.geobackend.util.DateUtils;

/**
 * A Row represents a set of values.
 * In a technical manner (e.g. database manner) a row contains all attributes of a single "hit".
 *
 * @author blume
 * @version 1.0
 * @serial 1.0
 * @see
 * @since 21.11.2007 11:00:54
 */
public class Row {

    /**
     * Default Logging instance
     */
    private static Logger sLogger = Logger.getLogger(Row.class);
    private static boolean sDebug = sLogger.isDebugEnabled();

    /**
     * Data container.
     */
    private Object[] mObjects;

    /**
     * Constructor.
     *
     * @param pRowSize the number of attributes contained by this row.
     */
    public Row(int pRowSize) {
        mObjects = new Object[pRowSize];
    }
    
    /**
     * Constructor.
     *
     * @param ArrayStr a line from CSV-File.
     */
    public Row (String[] ArrayStr){
    	this (ArrayStr.length);
    	int nLength = ArrayStr.length;
    	for (int i=0; i < nLength; i++){
    		//if (sDebug)
    		//	sLogger.debug(" ArrayStr["+i+" ]=" + ArrayStr[i]);
    		addObject(ArrayStr[i], i);
    		
    	}	
    	
    }
    
    
    /**
     * Adds an attribute value to a specific position of this row.
     *
     * @param pObject the object to be stored.
     * @param pPos    the postion the value to be saved
     */
    public void addObject(Object pObject, int pPos) {
        mObjects[pPos] = pObject;
    }

    /**
     * Returns a Value out of the Row.
     *
     * @param pPos the position of the value to be returned.
     * @return an Object! (not strongly typed)
     * @throws TechnicalException
     */
    public Object getValue(int pPos) throws TechnicalException {
        if (pPos < mObjects.length) {
            return mObjects[pPos];
        } else {
            throw new TechnicalException("Cannot access this field position. Size is: " + mObjects.length);
        }
    }


    /**
     * This is a covenient method for getting strongly typed objects out of the row.
     * It has to be ensured, that the type of the requested row position has been resolved out of the ColumnDefinition ({@link ResultSet#getColumnDefinitions()}).
     * In fact, this method executes a simple cast to the desired type.
     *
     * @param pPos the position of the object to be resolved.
     * @return a strongly typed Date
     * @throws TechnicalException
     * @see #getValue(int)
     */
    public Date getDateValue(int pPos) throws TechnicalException {
    	Date date =  null;
        try {
            Calendar lCalendar = (Calendar) getValue(pPos);
            date = lCalendar.getTime();
        } 
        catch (ClassCastException e) {
        	try{
        		//SimpleDateFormat formatter = new SimpleDateFormat("dd-MMM-yyyy HH:mm:ss");
        		date = DateUtils.getDateFromString ((String)getValue(pPos)); //(Date)formatter.parse((String)getValue(pPos));
        	    
        		
        	}
        	catch (Exception ex){
        		sLogger.error(getValue(pPos) + " " + ex.getMessage(), ex);
        		throw new TechnicalException("Could not cast this value to the Date Type. Object is of value type: " + getValue(pPos).getClass().getName());
        	}
        }	
      
        return date;
    }

    /**
     * This is a covenient method for getting strongly typed objects out of the row.
     * It has to be ensured, that the type of the requested row position has been resolved out of the ColumnDefinition ({@link ResultSet#getColumnDefinitions()}).
     * In fact, this method executes a simple cast to the desired type.
     *
     * @param pPos the position of the object to be resolved.
     * @return a strongly typed String
     * @throws TechnicalException
     * @see #getValue(int)
     */
    public String getStringValue(int pPos) throws TechnicalException {
        try {
            return (String) getValue(pPos);
        } catch (ClassCastException e) {
            throw new TechnicalException("Could not cast this value to the String Type. Object is of value type: " + getValue(pPos).getClass().getName());
        }
    }

    /**
     * This is a covenient method for getting strongly typed objects out of the row.
     * It has to be ensured, that the type of the requested row position has been resolved out of the ColumnDefinition ({@link ResultSet#getColumnDefinitions()}).
     * In fact, this method executes a simple cast to the desired type.
     *
     * @param pPos the position of the object to be resolved.
     * @throws TechnicalException
     * @see #getValue(int)
     *      * @return a strongly typed int
     */
    public int getIntValue(int pPos) throws TechnicalException {
        try {
            return (Integer) getValue(pPos);
        } catch (ClassCastException e) {
            throw new TechnicalException("Could not cast this value to the Integer Type. Object is of value type: " + getValue(pPos).getClass().getName());
        }
    }

    /**
     * This is a covenient method for getting strongly typed objects out of the row.
     * It has to be ensured, that the type of the requested row position has been resolved out of the ColumnDefinition ({@link ResultSet#getColumnDefinitions()}).
     * In fact, this method executes a simple cast to the desired type.
     *
     * @param pPos the position of the object to be resolved.
     * @throws TechnicalException
     * @see #getValue(int)
     *      * @return a strongly typed Double
     */
    public Double getDoubleValue(int pPos) throws TechnicalException {
        try {
            return (Double) getValue(pPos);
        } catch (ClassCastException e) {
        	try{
        		return new Double ((String)getValue(pPos));
        	}
        	catch(Exception ex){
        		sLogger.error(getValue(pPos) + " " + ex.getMessage(), ex);
        		throw new TechnicalException("Could not cast this value to the Double Type. Object is of value type: " + getValue(pPos).getClass().getName());
        	}
        }
    }

    /**
     * This is a covenient method for getting strongly typed objects out of the row.
     * It has to be ensured, that the type of the requested row position has been resolved out of the ColumnDefinition ({@link ResultSet#getColumnDefinitions()}).
     * In fact, this method executes a simple cast to the desired type.
     *
     * @param pPos the position of the object to be resolved.
     * @return a strongly typed Float
     * @throws TechnicalException
     * @see #getValue(int)
     */
    public Float getFloatValue(int pPos) throws TechnicalException {
        try {
            return (Float) getValue(pPos);
        } catch (ClassCastException e) {
            throw new TechnicalException("Could not cast this value to the Float Type. Object is of value type: " + getValue(pPos).getClass().getName());
        }
    }
    /**
     * This is a covenient method for getting strongly typed objects out of the row.
     * It has to be ensured, that the type of the requested row position has been resolved out of the ColumnDefinition ({@link ResultSet#getColumnDefinitions()}).
     * In fact, this method executes a simple cast to the desired type.
     *
     * @param pPos the position of the object to be resolved.
     * @return a strongly typed Float
     * @throws TechnicalException
     * @see #getValue(int)
     */    
    public String getPosValue(int pPos)throws TechnicalException{
    	SeShape val;
    	ArrayList aList;
    	SDEPoint mPoint[];
    	double lat,lon;
    	try {
    		val = (SeShape) getValue(pPos);
    		aList = val.getAllPoints(0,false);
    		mPoint = (SDEPoint[])aList.get(0);
    		lat = mPoint[0].getY();
    		lon = mPoint[0].getX();
    		String nord="N";
    		String ost="E";
    		if (lat <0 ){nord="S"; lat=-lat;}
    		if (lon <0 ){ost="W"; lon=-lon;}
    		return String.format("%1$02d�%2$1S %3$05.2f' %4$03d�%5$1S %6$05.2f'",
    				              (int)lat, nord,60.*(lat-((int)lat)),(int)lon,ost,60.*(lon-((int)lon)));
    				              

        } catch (SeException e) {
            throw new TechnicalException("Could not cast this value to the Float Type. Object is of value type: " + getValue(pPos).getClass().getName());   
        }
    }
}