root/trunk/src/main/groovy/org/chama/builder/model/QueryBuilder.groovy

package org.chama.builder.model

import org.codehaus.groovy.runtime.InvokerHelper
import groovy.lang.Closure

import java.util.List
import java.util.Map

import org.chama.Inflection

class QueryBuilder {
    def tableName
    def className
    def returnType
    def query
    def criteria
    def parent
    
    //conditionals
    def static AND = "and"; // builder
    def static IS_NULL = "isNull"; // builder
        def static IS_NOT_NULL = "notNull"; // builder
        def static NOT = "not";// builder
        def static OR = "or"; // builder
        def static ID_EQUALS = "idEq"; // builder
        def static IS_EMPTY = "isEmpty"; //builder
        def static IS_NOT_EMPTY = "isNotEmpty"; //builder
        
        def static SELECT = "select" //method
        def static DELETE = "delete" //method
    def static BETWEEN = "between" //method
    def static EQUALS = "eq" //method
    def static EQUALS_PROPERTY = "eqProperty" //method
    def static GREATER_THAN = "gt" //method
    def static GREATER_THAN_PROPERTY = "gtProperty" //method
    def static GREATER_THAN_OR_EQUAL = "ge" //method
    def static GREATER_THAN_OR_EQUAL_PROPERTY = "geProperty" //method
    def static ILIKE = "ilike" //method
    def static IN = "in" //method
    def static LESS_THAN = "lt" //method
    def static LESS_THAN_PROPERTY = "ltProperty" //method
    def static LESS_THAN_OR_EQUAL = "le" //method
    def static LESS_THAN_OR_EQUAL_PROPERTY = "leProperty" //method
    def static LIKE = "like" //method
    def static NOT_EQUAL = "ne" //method
    def static NOT_EQUAL_PROPERTY = "neProperty" //method
    def static SIZE_EQUALS = "sizeEq" //method
    def static ORDER_DESCENDING = "desc"
    def static ORDER_ASCENDING = "asc"
    
    def queryTypes = ['select', 'update', 'remove']
        
        def QueryBuilder(className, returnType) {
            this.className = className
            this.returnType = returnType
        this.tableName = Inflection.pluralize(className)
        }
        
    def Object invokeMethod(String methodName, arguments) {
        List list = InvokerHelper.asList(arguments)
        def name = methodName
        def closure = null
            println "attempting to call method: ${methodName} with arguments ${arguments} inside QueryBuilder"
            if(criteria == null) {
                println "criteria is null"
                if(queryTypes.contains(name)) {
                        this.criteria = new Criteria(this.className, name)
                    }
            }
            switch (list.size()) {
                case 0:
                            //probably will need this, just not yet
                            break
                case 1:
                                def object = list.get(0)
                                if (object instanceof Closure) {
                                    println "${methodName} closure getting called"
                    closure = object
                                    closure.delegate = this
                                    closure.call()
                } else {
                    println "creating restriction with ${name} ${object}"
                    createRestriction(name, null, object)
                }
                break
                case 2:
                    def object1 = list.get(0)
                    def object2 = list.get(1)
                    if (object2 instanceof Closure) {
                    createRestriction(name, null, object1)
                    closure = object2
                        closure.delegate = this
                    closure.call()
                                } else if (object2 instanceof Map) {
                                    println "object 2 is a map"
                } else {
                                    createRestriction(name, object1, object2)
                                }
                        break
            }
            //figure out return type and return an empty version of that
            def returnValue
            if(returnType == int) {
                returnValue = 0
            } else if(returnType == boolean) {
                returnValue = true
            } else if(returnType == java.util.List) {
                returnValue = []
            } else if(returnType instanceof Object) {
                returnValue = InvokerHelper.invokeNoArgumentsConstructorOf(returnType)
            } else {
                returnValue = null
            }
            return returnValue
        }
    
    def createRestriction(type, name, value) {
        def currRestriction
        println "createRestriction ${type}, ${name}, ${value}"
        switch(type) {
            case SELECT:
                // need to modify the criteria with columns
                criteria.columns = value
                break
            case LIKE:
                currRestriction = Restriction.like(name, value)
                break
            case ID_EQUALS:
                currRestriction = Restriction.pkEq(className, "id", value)
                break
            case EQUALS:
                currRestriction = Restriction.eq(name, value)
                break
        }
        if(parent != null && currRestriction != null) {
            restriction.add(currRestriction)
        } else if(parent == null && currRestriction != null) {
            //add it to the criteria instead
            criteria.add(currRestriction)
        }
    }
    
    def buildCriteria() {
        return buildReturn() + this.criteria.getQuery()
    }
    
    def private buildReturn() {
        println "return type is ${returnType}"
        def returnStr = "        "
            if(returnType == int) {
                returnStr += "return "
            } else if(returnType == boolean) {
                returnStr += "return "
            } else if(returnType == java.util.List) {
                returnStr += "return "
            } else if(returnType instanceof Object) {
                //we are actually returning the class we are looking up
                returnStr += "return (${className}) "
            }
        return returnStr
    }

}