////
import groovy.json.JsonSlurper
import groovy.transform.Field

class Logger {
    private boolean printToConsole = true

    def methodMissing(String name, args) {
        def messsage = args[0]
        if (printToConsole) {
            println messsage
        }
    }
}

///////////////////////////////////////////////////
class RequestBuckets {
	def jsonSlurper = new JsonSlurper()
	def JSON = jsonSlurper.parseText '''
    		{ 	
			"version": 1.06,
	      		"accessKey": 100,
	     		"bucketKey": 50,
			"bucketName": "TEST",
			"isBucketCreated": true,
			"grokerSubdomain": "DOMAIN"
    		}'''
}
///////////////////////////////////////////////////


///////////////////////////////////////////////////
class Atomic {
	def version
	def accessKey
	def bucketKey
	def bucketName
	def isBucketCreated
	def grokerSubdomain
}
///////////////////////////////////////////////////

@Field def log = new Logger()
///////////////////////////////////////////////////
@Field def atomicState = new Atomic()
@Field def request = new RequestBuckets()
///////////////////////////////////////////////////


getAccessKey()
getBucketKey()
setBucketKey()
setAccessKey()
tryCreateBucket()

///////////////////////////////////////////////////
def httpError(int errorNumber, String errorReport) {
	println("---Just IGNORE---For http connection in a streamer app")
}
def httpPostJson(LinkedHashMap metaData, Closure Input) {
	Input(metaData)
}
///////////////////////////////////////////////////



def getAccessKey() {
	log.trace "get access key"
	if (atomicState.accessKey == null) {
		httpError(404, "Access Key Not Found")
	} else {
		[
			accessKey: atomicState.accessKey
		]
	}
}

def getBucketKey() {
	log.trace "get bucket key"
	if (atomicState.bucketKey == null) {
		httpError(404, "Bucket key Not Found")
	} else {
		[
			bucketKey: atomicState.bucketKey,
			bucketName: atomicState.bucketName
		]
	}
}

def setBucketKey() {
	log.trace "set bucket key"
	def newBucketKey = request.JSON?.bucketKey
	def newBucketName = request.JSON?.bucketName

	log.debug "bucket name: $newBucketName"
	log.debug "bucket key: $newBucketKey"

	if (newBucketKey && (newBucketKey != atomicState.bucketKey || newBucketName != atomicState.bucketName)) {
		atomicState.bucketKey = "$newBucketKey"
		atomicState.bucketName = "$newBucketName"
		atomicState.isBucketCreated = false
	}

	tryCreateBucket()
}

def setAccessKey() {
	log.trace "set access key"
	def newAccessKey = request.JSON?.accessKey
	def newGrokerSubdomain = request.JSON?.grokerSubdomain

	if (newGrokerSubdomain && newGrokerSubdomain != "" && newGrokerSubdomain != atomicState.grokerSubdomain) {
		atomicState.grokerSubdomain = "$newGrokerSubdomain"
		atomicState.isBucketCreated = false
	}

	if (newAccessKey && newAccessKey != atomicState.accessKey) {
		atomicState.accessKey = "$newAccessKey"
		atomicState.isBucketCreated = false
	}
}



def tryCreateBucket() {

	// can't ship events if there is no grokerSubdomain
	if (atomicState.grokerSubdomain == null || atomicState.grokerSubdomain == "") {
		log.error "streaming url is currently null"
		return
	}

	// if the bucket has already been created, no need to continue
	if (atomicState.isBucketCreated) {
		return
	}

	if (!atomicState.bucketName) {
    	atomicState.bucketName = atomicState.bucketKey
    }
    if (!atomicState.accessKey) {
    	return
    }
	def bucketName = "${atomicState.bucketName}"
	def bucketKey = "${atomicState.bucketKey}"
	def accessKey = "${atomicState.accessKey}"

	def bucketCreateBody = new JsonSlurper().parseText("{\"bucketKey\": \"$bucketKey\", \"bucketName\": \"$bucketName\"}")

	def bucketCreatePost = [
		uri: "https://${atomicState.grokerSubdomain}.initialstate.com/api/buckets",
		headers: [
			"Content-Type": "application/json",
			"X-IS-AccessKey": accessKey
		],
		body: bucketCreateBody
	]

	log.debug bucketCreatePost

	try {
		// Create a bucket on Initial State so the data has a logical grouping
		httpPostJson(bucketCreatePost) { resp ->
			log.debug "bucket posted"
			if (resp.status >= 400) {
				log.error "bucket not created successfully"
			} else {
				atomicState.isBucketCreated = true
			}
		}
	} catch (e) {
		log.error "bucket creation error: $e"
	}

}