/**
 * The contents of this file are subject to the OpenMRS Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://license.openmrs.org
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
 * License for the specific language governing rights and limitations
 * under the License.
 *
 * Copyright (C) OpenMRS, LLC.  All Rights Reserved.
 */
package org.eclipse.datatools.connectivity.oda.openmrs.impl;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.eclipse.datatools.connectivity.oda.IResultSetMetaData;
import org.eclipse.datatools.connectivity.oda.OdaException;

/**
 * Implementation class of IResultSetMetaData for OpenMRS ODA runtime driver.
 */
public class ResultSetMetaData implements IResultSetMetaData {
   
    private static final String MOSTRECENT = "mostrecent";

    private static final String FLAT = "flat";

    private static final String ENCOUNTERTYPE = "ENCOUNTERTYPE";

    private static final String ENCOUNTERDATE = "ENCOUNTERDATE";

    private static final String OBSERVATIONLOCATION = "OBSERVATIONLOCATION";

    private static final String OBSERVATIONDATE = "OBSERVATIONDATE";

    private static final String STACKED = "stacked";

    private static final String PATIENTID = "PATIENTID";

    private List<Token> columns;

    private Logger log = Logger.getLogger(ResultSetMetaData.class.getName());
  /**
     * Instantiates new ResultSetMetaData.
     * 
     * @param tokens the Token objects for the query
     * @param dataStyle the data style
     */
    public ResultSetMetaData(List<Token> tokens, String dataStyle) {
        log.setLevel(Level.INFO);

        log.info("Entered constructor");

        columns = new ArrayList<Token>();

        // we always want to add the patient id first
        Token patientIdToken = new Token(PATIENTID, "TEXT");
        columns.add(patientIdToken);

        if (dataStyle.equals(STACKED)) {
            Token keyToken = new Token("TOKEN", "TEXT");
            columns.add(keyToken);

            Token valueToken = new Token("VALUE", "TEXT");
            columns.add(valueToken);

            // if any of the tokens are to be split, we need to add another
            // column

            boolean observationDate = false;
            boolean observationLocation = false;
            boolean encounterDate = false;
            boolean encounterType = false;
            for (Token token : tokens) {
                if (token.isSplitObservationDate() && !observationDate) {
                    Token dateToken = new Token(OBSERVATIONDATE, "DATETIME");
                    columns.add(dateToken);
                    observationDate = true;
                }

                if (token.isSplitObservationLocation() && !observationLocation) {
                    Token locationToken = new Token(OBSERVATIONLOCATION,
                            "TEXT");
                    columns.add(locationToken);
                    observationLocation = true;
                }

                if (token.isSplitEncounterDate() && !encounterDate) {
                    Token encounterDateToken = new Token(ENCOUNTERDATE,
                            "DATETIME");
                    columns.add(encounterDateToken);
                    encounterDate = true;
                }

                if (token.isSplitEncounterType() && !encounterType) {
                    Token encounterTypeToken = new Token(ENCOUNTERTYPE,
                            "TEXT");
                    columns.add(encounterTypeToken);
                    encounterType = true;
                }
            }
        }

        else if (dataStyle.equals(FLAT)) {
            //int max = 5;

            // explode columns
            for (int i = 0; i < tokens.size(); i++) 
            {   
                int max = Integer.parseInt(tokens.get(i).getAggregateValue());
                
                for (int j = 1; j < max + 1; j++) {
                    String name = tokens.get(i).getName();

                    int type = tokens.get(i).getType();

                    columns.add(new Token(name + "_" + j, type));

                    if (tokens.get(i).isSplitObservationDate()) {
                        Token dateToken = new Token(name + "_" + j
                                + "_" + OBSERVATIONDATE, "DATETIME");
                        columns.add(dateToken);
                    }

                    if (tokens.get(i).isSplitObservationLocation()) {
                        Token locationToken = new Token(name + "_" + j
                                + "_" + OBSERVATIONLOCATION, "TEXT");
                        columns.add(locationToken);
                    }

                    if (tokens.get(i).isSplitEncounterDate()) {
                        Token encounterDateToken = new Token(name + "_" + j
                                + "_" + ENCOUNTERDATE, "DATETIME");
                        columns.add(encounterDateToken);
                    }

                    if (tokens.get(i).isSplitEncounterType()) {
                        Token encounterTypeToken = new Token(name + "_" + j
                                + "_" + ENCOUNTERTYPE, "TEXT");
                        columns.add(encounterTypeToken);
                    }

                }
            }
        }

        else if (dataStyle.equals(MOSTRECENT)) {
            // inject any additional columns
            for (int i = 0; i < tokens.size(); i++) {
                columns.add(tokens.get(i));

                if (tokens.get(i).isSplitObservationDate()) {
                    Token dateToken = new Token(tokens.get(i).getName()
                            + "_" + OBSERVATIONDATE, "DATETIME");
                    columns.add(dateToken);
                }

                if (tokens.get(i).isSplitObservationLocation()) {
                    Token locationToken = new Token(tokens.get(i).getName()
                            + "_" + OBSERVATIONLOCATION, "TEXT");
                    columns.add(locationToken);
                }

                if (tokens.get(i).isSplitEncounterDate()) {
                    Token dateToken = new Token(tokens.get(i).getName()
                            + "_" + ENCOUNTERDATE, "DATETIME");
                    columns.add(dateToken);
                }

                if (tokens.get(i).isSplitEncounterType()) {
                    Token typeToken = new Token(tokens.get(i).getName()
                            + "_" + ENCOUNTERTYPE, "TEXT");
                    columns.add(typeToken);
                }
            }
        }

        log.info("End of constructor");

    }

    /*
     * @see org.eclipse.datatools.connectivity.oda.IResultSetMetaData#getColumnCount()
     */
    public int getColumnCount() throws OdaException {
        return columns.size();
    }

    /*
     * @see org.eclipse.datatools.connectivity.oda.IResultSetMetaData#getColumnName(int)
     */
    public String getColumnName(int index) throws OdaException {
        return columns.get(index - 1).getName();
    }

    /*
     * @see org.eclipse.datatools.connectivity.oda.IResultSetMetaData#getColumnLabel(int)
     */
    public String getColumnLabel(int index) throws OdaException {
        return getColumnName(index);
    }

    /*
     * @see org.eclipse.datatools.connectivity.oda.IResultSetMetaData#getColumnType(int)
     */
    public int getColumnType(int index) throws OdaException {
        return columns.get(index - 1).getType();
    }

    /*
     * @see org.eclipse.datatools.connectivity.oda.IResultSetMetaData#getColumnTypeName(int)
     */
    public String getColumnTypeName(int index) throws OdaException {
        int nativeTypeCode = getColumnType(index);
        return Driver.getNativeDataTypeName(nativeTypeCode);
    }

    /*
     * @see org.eclipse.datatools.connectivity.oda.IResultSetMetaData#getColumnDisplayLength(int)
     */
    public int getColumnDisplayLength(int index) throws OdaException {
        return -1; // Don't set display lengths
    }

    /*
     * @see org.eclipse.datatools.connectivity.oda.IResultSetMetaData#getPrecision(int)
     */
    public int getPrecision(int index) throws OdaException {
        return columns.get(index - 1).getPrecision();
    }

    /*
     * @see org.eclipse.datatools.connectivity.oda.IResultSetMetaData#getScale(int)
     */
    public int getScale(int index) throws OdaException {
        return columns.get(index - 1).getScale();
    }

    /*
     * @see org.eclipse.datatools.connectivity.oda.IResultSetMetaData#isNullable(int)
     */
    public int isNullable(int index) throws OdaException {
        return columnNullableUnknown;
    }

}