package jdo.bug1276;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.TimeZone;
import junit.framework.Assert;

import junit.framework.TestCase;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.exolab.castor.jdo.CacheManager;

import org.exolab.castor.jdo.Database;
import org.exolab.castor.jdo.JDOManager;
import org.exolab.castor.jdo.OQLQuery;
import org.exolab.castor.jdo.PersistenceException;
import org.exolab.castor.jdo.QueryResults;
import org.exolab.castor.util.LocalConfiguration;

public final class TestTemplate extends TestCase {
    private static final String JDO_CONF_FILE = "jdo-conf.xml";
    private static final String DATABASE_NAME = "bugTemplate";
    private static final Log log = LogFactory.getLog(TestTemplate.class);
    private static final DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss z");

    
    private JDOManager _jdo = null;

    public static void main(final String[] args) throws Exception {
        TestTemplate test = new TestTemplate();
        test.setUp();
        test.testQueryEntityOne();
        test.tearDown();
    }
    
    public TestTemplate() {
        super();
    }
    
    public TestTemplate(final String name) {
        super(name);
    }

    protected void setUp() throws Exception {
        super.setUp();
        
        String config = getClass().getResource(JDO_CONF_FILE).toString();
        JDOManager.loadConfiguration(config, getClass().getClassLoader());
        _jdo = JDOManager.createInstance(DATABASE_NAME);
    }
    
    protected void tearDown() throws Exception {
        super.tearDown();
    }

    public void testTimestamp() throws Exception {
        String testTimezone = "UTC";
        
        String timeZone = System.getProperty("user.timezone");
        log.debug("user.timezone = " + timeZone + ", org.exolab.castor.jdo.defaultTimeZone = " + testTimezone);
        
        LocalConfiguration config = LocalConfiguration.getInstance();
        config.getProperties().setProperty("org.exolab.castor.jdo.defaultTimeZone", testTimezone);

        /*
         * Create a date object
         */
        String dateString = "1968-09-22 00:00:00 " + testTimezone;
        Date date = null;
        try {
            date = formatter.parse(dateString);
        }
        catch (ParseException e) {
            log.error("ParseException thrown", e);
            Assert.fail("Unable to parse " + dateString);
        }
        log.debug("Date = " + dateString + "[" + date.getTime() + "]");

        /*
         * Insert into the database
         */
        Database database = _jdo.getDatabase();
        database.begin();
        EntityOne entity = new EntityOne();
        entity.setId(new Integer(100));
        entity.setName("entity 100");
        entity.setStartDate(date);
        entity.setStartTime(date);
        entity.setStartTimestamp(date);
        database.create(entity);
        database.commit();
        database.begin();
        int id = entity.getId();
        
        /*
         * Clear the cache to ensure we aren't reading cached data
         */
        log.debug("Clearing Castor's cache");
        CacheManager cacheManager = database.getCacheManager();
        cacheManager.expireCache();

        /*
         * fetch the object again
         */
        log.debug("Fetching EnityOne with id = " + id + " from database");
        EntityOne entityRemove = (EntityOne) database.load(EntityOne.class, new Integer(id));
        Date insertedDate = entityRemove.getStartDate();
        Date insertedTime = entityRemove.getStartTime();
        Date insertedTimestamp = entityRemove.getStartTimestamp();
        
        
        Assert.assertEquals("Date did not survive the round trip!! Inserted: " + formatter.format(date) +
                "[" + date.getTime() + "], Retrieved: " + insertedTimestamp + "[" + insertedTimestamp.getTime() + "]", date, insertedTimestamp);
        
        /*
        Assert.assertEquals("Time did not survive the round trip!! Inserted: " + formatter.format(date) +
                "[" + date.getTime() + "], Retrieved: " + insertedTime + "[" + insertedTime.getTime() + "]", date, insertedTime);
                
        Assert.assertEquals("Timestamp did not survive the round trip!! Inserted: " + formatter.format(date) +
                "[" + date.getTime() + "], Retrieved: " + insertedTimestamp + "[" + insertedTimestamp.getTime() + "]", date, insertedTimestamp);
            */
        
        log.debug("Success!! Inserted: " + formatter.format(date) + ", Retrieved: " + formatter.format(insertedTimestamp));

        /*
         * Attempt to fetch using straight SQL and compare the result with our 
         * original date
         */
        Calendar calendar = new GregorianCalendar(TimeZone.getTimeZone("UTC"));
        String sql = "SELECT start_stamp FROM entity1 WHERE id = " + id;
        try {
            database.begin();
            Connection connection = database.getJdbcConnection();
            Statement statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery(sql);
            resultSet.next();
            Date localDate = resultSet.getTimestamp(1);
            Date utcDate = resultSet.getTimestamp(1, calendar);
            database.commit();
            database.close();
            log.debug("SQL retrieved " + formatter.format(localDate) + " [" + localDate.getTime() + "] without a Calendar");
            log.debug("SQL retrieved " + formatter.format(utcDate) + " [" + utcDate.getTime() + "] with a " + testTimezone + " Calendar");
            Assert.assertEquals("Date fetched via Castor and SQL are not the same", date, utcDate);
        }
        catch (PersistenceException e) {
            log.error("PersistenceException thrown", e);
            Assert.fail();
        }
        catch (SQLException e) {
            log.error("SQLException thrown", e);
            Assert.fail();
        }

        timeZone = System.getProperty("user.timezone");
        log.debug("user.timezone = " + timeZone);
        
    }

    
    /**
     * Test method.
     * @throws Exception For any exception thrown.
     */
    public void testQueryEntityOne() throws Exception {
        Database db = _jdo.getDatabase();
        db.begin();
        
        OQLQuery query = db.getOQLQuery("SELECT entity FROM "
                + EntityOne.class.getName() + " entity WHERE id = $1");
        query.bind(new Integer(1));
        QueryResults results = query.execute();
        
        EntityOne entity = (EntityOne) results.next();

        assertNotNull(entity);
        assertEquals(new Integer(1), entity.getId());
        
        db.commit();
        db.close();
    }
    
    public void testCreateEntity() throws Exception {
        Database db = _jdo.getDatabase();
        db.begin();
        EntityOne entity = new EntityOne();
        entity.setId(new Integer(100));
        entity.setName("entity 100");
        Date now = new Date();
        entity.setStartDate(now);
        entity.setStartTime(now);
        entity.setStartTimestamp(now);
        db.create(entity);
        db.commit();
        
        db.begin();
        EntityOne entityLoad = (EntityOne) db.load(EntityOne.class, new Integer(100));
        assertNotNull(entityLoad);
        assertEquals (new Integer(100), entityLoad.getId());
        assertEquals ("entity 100", entityLoad.getName());
        assertEquals (now, entityLoad.getStartDate());
        Date startTimeLoaded = entityLoad.getStartTime();
        assertEquals(now, startTimeLoaded);
        Date startTimestampLoaded = entityLoad.getStartTimestamp();
        assertEquals(now, startTimestampLoaded);
        db.commit();
        
        db.begin();
        EntityOne entityRemove = (EntityOne) db.load(EntityOne.class, new Integer(100));
        db.remove(entityRemove);
        db.commit();
        
        db.close();
        
    }
    
    public void testCreateEntityWithDifferentTimeZone() throws Exception {
        Database db = _jdo.getDatabase();
        
        LocalConfiguration config = LocalConfiguration.getInstance();
        
        config.getProperties().setProperty("org.exolab.castor.jdo.defaultTimeZone", "GMT+07:00");
        
        db.begin();
        EntityOne entity = new EntityOne();
        entity.setId(new Integer(100));
        entity.setName("entity 100");
        Date now = new Date();
        entity.setStartDate(now);
        entity.setStartTime(now);
        entity.setStartTimestamp(now);
        db.create(entity);
        db.commit();

        config.getProperties().setProperty("org.exolab.castor.jdo.defaultTimeZone", "GMT+01:00");

        db.begin();
        EntityOne entityLoad = (EntityOne) db.load(EntityOne.class, new Integer(100));
        assertNotNull(entityLoad);
        assertEquals (new Integer(100), entityLoad.getId());
        assertEquals ("entity 100", entityLoad.getName());
        assertEquals (now, entityLoad.getStartDate());
        Date startTimeLoaded = entityLoad.getStartTime();
        assertEquals(now, startTimeLoaded);
        Date startTimestampLoaded = entityLoad.getStartTimestamp();
        assertEquals(now, startTimestampLoaded);
        db.commit();
        
        db.begin();
        EntityOne entityRemove = (EntityOne) db.load(EntityOne.class, new Integer(100));
        db.remove(entityRemove);
        db.commit();
        
        db.close();
        
    }

}