/* Copyright 2006-2007 Graeme Rocher
 *
 * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package groovy.util


/**
* A ConfigObject at a simple level is a Map that creates configuration entries (other ConfigObjects) when referencing them.
* This means that navigating to foo.bar.stuff will not return null but nested ConfigObjects which are of course empty maps
* The Groovy truth can be used to check for the existance of "real" entries.
*
* @author Graeme Rocher
* @since 1.1
*/
class ConfigObject extends LinkedHashMap implements Writable {

    // would be better to have these availabe as constants from Groovy, but couldn't find
    static final KEYWORDS = ['class', 'extends', 'implements', 'package','return','def',
                             'try','finally','this','new','catch','switch','case','default','while','if',
                             'else','elseif','private','protected','final','for','in','byte','short','break',
                             'instanceof','synchronized','const','float','null','throws','do','super','with',
                             'threadsafe','transient','native','interface','any','double','volatile','as',
                             'assert','goto','enum','int','boolean','char','false','true','static','abstract',
                             'continue','import','void','long']

    static final TAB_CHARACTER = '\t'

	/**
	 * The config file that was used when parsing this ConfigObject
	 */
    URL configFile

    ConfigObject(URL file) {
        this.configFile = file
    }

    ConfigObject() {}

    /**
	 * Writes this config object into a String serialized representation which can later be parsed back using the parse()
	 * method
	 *
     * @see groovy.lang.Writable#writeTo(java.io.Writer)
     * @see #parse(URL)
     */ 
	Writer writeTo(Writer outArg) {
        def out
        try {
            out = new BufferedWriter(outArg)
            writeConfig("",this, out, 0, false)
        } finally {
            out.flush()
        }

		return outArg
	}
                  

    /**
     * Overrides the default getProperty implementation to create nested ConfigObject instances on demand
     * for non-existant keys
     */
    def getProperty(String name) {  
		if(name == 'configFile') return this.configFile
        def prop = get(name)
        if(prop == null) prop = new ConfigObject(this.configFile)
        put(name, prop)
        return prop
    }
    
    /**
     * A ConfigObject is a tree structure consisting of nested maps. This flattens the maps into
     * a single level structure like a properties file
     */
    Map flatten() {
        return flatten(null)
    }
    /**
     * Flattens this ConfigObject populating the results into the target Map
     *
     * @see ConfigObject#flatten()
     */
    Map flatten(Map target) {
        if(target == null)target = new ConfigObject()
        populate("", target, this)
        target
    }

    /**
     * Merges the given map with this ConfigObject overriding any matching configuration entries in this ConfigObject
     *
     * @param other The ConfigObject to merge with
     * @return The result of the merge
     */
    Map merge(ConfigObject other) {
        return merge(this,other)
    }


    /**
     * Converts this ConfigObject into a the java.util.Properties format, flattening the tree structure beforehand
     * @return A java.util.Properties instance
     */
    Properties toProperties() {
        def props = new Properties()
        flatten(props)
        props = convertValuesToString(props)
        return props
    }

    /**
     * Converts this ConfigObject ino the java.util.Properties format, flatten the tree and prefixing all entries with the given prefix
     * @param prefix The prefix to append before property entries
     * @return A java.util.Properties instance
     */
    Properties toProperties(String prefix) {
        def props = new Properties()
        populate("${prefix}.", props, this)
        props = convertValuesToString(props)
        return props
    }

    private merge(Map config, Map other) {
        for(entry in other) {

            def configEntry = config[entry.key]
            if(configEntry == null) {
                config[entry.key] = entry.value
                continue
            }
            else {
                if(configEntry instanceof Map && configEntry.size() > 0 && entry.value instanceof Map) {
                    // recurse
                    merge(configEntry, entry.value)
               }
               else {
                    config[entry.key] = entry.value
               }
            }
        }
        return config

    }

    private writeConfig(String prefix,ConfigObject map, out, Integer tab, boolean apply) {
        def space = apply ? TAB_CHARACTER*tab : ''
        for(key in map.keySet()) {
            def value = map.get(key)


			if(value instanceof ConfigObject) {
                def dotsInKeys = value.find { entry -> entry.key.indexOf('.') > -1 }
                def configSize = value.size()
                def firstKey = value.keySet().iterator().next()
                def firstValue = value.values().iterator().next()
                def firstSize
                if(firstValue instanceof ConfigObject){
                    firstSize = firstValue.size()
                }
                else { firstSize = 1 }
				if(configSize == 1|| dotsInKeys )  {

                    if(firstSize == 1 && firstValue instanceof ConfigObject) {
                        key = KEYWORDS.contains(key) ? key.inspect() : key
                        def writePrefix = "${prefix}${key}.${firstKey}."
                        writeConfig(writePrefix, firstValue, out, tab, true)
                    }
                    else if(!dotsInKeys && firstValue instanceof ConfigObject) {
                        writeNode(key, space, tab,value, out)
                    }  else {
                        for(j in value.keySet()) {
                            def v2 = value.get(j)
                            def k2 = j.indexOf('.') > -1 ? j.inspect() : j
                            if(v2 instanceof ConfigObject) {
                                key = KEYWORDS.contains(key) ? key.inspect() : key
                                writeConfig("${prefix}${key}", v2, out, tab, false)
                            }
                            else {
                                writeValue("${key}.${k2}", space, prefix, v2, out)
                            }
                        }
                    }

				}
				else {
                    writeNode(key, space,tab, value, out)
				}
			}
			else {

                writeValue(key, space, prefix, value, out)
			}
		}
	}

    private writeValue(key, space, prefix, value, out) {
        key = key.indexOf('.') > -1 ? key.inspect() : key
        boolean isKeyword = KEYWORDS.contains(key)
        key = isKeyword ? key.inspect() : key

        if(!prefix && isKeyword) prefix = "this."
        out << "${space}${prefix}$key=${value.inspect()}"
        out.newLine()
    }

    private writeNode(key, space, tab, value, out) {
        key = KEYWORDS.contains(key) ? key.inspect() : key
        out << "${space}$key {"
        out.newLine()
        writeConfig("",value, out, tab+1, true)
        def last = "${space}}"
        out << last
        out.newLine()
    }

    private convertValuesToString(props) {
        def newProps = [:]
        for(e in props) {
            newProps[e.key] = e.value?.toString()
        }
        return newProps
    }

    private populate(suffix, config, map) {
        for(key in map.keySet()) {
            def value = map.get(key)
            if(value instanceof Map) {
                populate(suffix+"${key}.", config, value)
            }
            else {
                config[suffix+key] = value
            }
        }
    }
}