from urllib2 import Request, urlopen, URLError
import json
import math
import sys
import os
import socket
import optparse

def arg_parser():
    cwd_dir = os.getcwd()
    parser = optparse.OptionParser()
    parser.add_option( '-r', dest='runid', help='Run ID: required')
    parser.add_option( '-a', dest='accesstoken', help='Access Token: required')
    ( options, args ) = parser.parse_args()

    try:
       if options.runid == None:
             raise Exception
       if options.accesstoken == None:
	     raise Exception

    except Exception:
	    print("Usage: BaseSpaceRunDownloader_vN.py -r <RunID> -a <AccessToken>")
	    sys.exit()

    return options

def restrequest(rawrequest):
	request = Request(rawrequest)

	try:
        	response = urlopen(request)
        	json_string = response.read()
        	json_obj = json.loads(json_string)

	except URLError, e:
    		print 'Got an error code:', e
		sys.exit()

	return json_obj

def downloadrestrequest(rawrequest,path):
	dirname = RunID + os.sep + os.path.dirname(path)

	if dirname != '':
		if not os.path.isdir(dirname):
			os.makedirs(dirname)

	request = (rawrequest)

	outfile = open(RunID + os.sep + path,'wb')

        try:
                response = urlopen(request,timeout=1)

		outfile.write(response.read())
		outfile.close()

        except URLError, e:
                print 'Got an error code:', e
		outfile.close()
		downloadrestrequest(rawrequest,path)


	except socket.error:
		print 'Got a socket error: retrying'
		outfile.close()
		downloadrestrequest(rawrequest,path)


options = arg_parser()

RunID = options.runid
AccessToken = options.accesstoken

request = 'http://api.basespace.illumina.com/v1pre3/runs/%s/files?access_token=%s' %(RunID,AccessToken)

json_obj = restrequest(request)
totalCount = json_obj['Response']['TotalCount']

noffsets = int(math.ceil(float(totalCount)/1000.0))

hreflist = []
pathlist = []
filenamelist = [] 
for index in range(noffsets):
	offset = 1000*index
	request = 'http://api.basespace.illumina.com/v1pre3/runs/%s/files?access_token=%s&limit=1000&Offset=%s' %(RunID,AccessToken,offset) 
	json_obj = restrequest(request)
	nfiles = len(json_obj['Response']['Items'])
	for fileindex in range(nfiles):
		href = json_obj['Response']['Items'][fileindex]['Href']
		hreflist.append(href)
		path = json_obj['Response']['Items'][fileindex]['Path']
		pathlist.append(path)

for index in range(len(hreflist)):
	request = 'http://api.basespace.illumina.com/%s/content?access_token=%s'%(hreflist[index],AccessToken)
	print 'downloading %s' %(pathlist[index]) 
	downloadrestrequest(request, pathlist[index])

library(Seurat)
library(dplyr)
## see https://bitbucket.org/snakemake/snakemake/issues/917/enable-stdout-and-stderr-redirection
log <- file(snakemake@log[[1]], open="wt")
sink(log)
sink(log, type="message")


# https://github.com/satijalab/seurat/issues/671
# run NormalizeData first and then FindVariableGenes
PreprocessData<- function(object,
                                x.low.cutoff = 0.05,
                                x.high.cutoff = 10,
                                y.cutoff = 0.5,
                                num.pc = 20,
                                pc.use = NULL,
                                do.par =TRUE,
                                num.cores = 2,
                                score.thresh = 1e-5,
                                sig.pc.thresh = 0.05,
                                n.start = 100,
                                nn.eps = 0,
                                resolution = 0.8,
                                k.param = 30,
                                ...){
		object<- NormalizeData(object = object)

        object<- FindVariableGenes(object = object,
                                   x.low.cutoff = x.low.cutoff,
                                   x.high.cutoff = x.high.cutoff,
                                   y.cutoff = y.cutoff)

        object<- ScaleData(object = object, genes.use = object@var.genes,
                           vars.to.regress = c("nUMI"), block.size = 1000,
                           min.cells.to.block=3000,
                           display.progress = TRUE, do.par = TRUE, num.cores = num.cores)

        object<- RunPCA(object = object, pc.genes = object@var.genes,
                        pcs.compute = num.pc, do.print = FALSE)

        if (is.null(pc.use)){
                object<- JackStraw( object = object, num.replicate = 100, num.cores = num.cores,
                                    do.par = T, num.pc = num.pc)

                object <- JackStrawPlot(object = object, PCs = 1:num.pc, score.thresh = score.thresh)

                PC_pvalues<- object@dr$pca@jackstraw@overall.p.values

                ## determin how many PCs to use.
                pc.use<- min(which(PC_pvalues[,"Score"] > sig.pc.thresh)) -1

        }

        # add significant pc number to metadata, need to have names same as the cells
        pc.use.meta<- rep(pc.use, length(object@cell.names))
        names(pc.use.meta)<- object@cell.names
        object<- AddMetaData(object = object, metadata = pc.use.meta, col.name = "pc.use")
        object <- RunTSNE(object = object, dims.use = 1:pc.use, do.fast = TRUE)
        object <- FindClusters(object = object, reduction.type = "pca",
                                dims.use = 1:pc.use,
                                n.start = n.start,
                                k.param = k.param,
                                nn.eps = nn.eps, resolution = resolution,
                                print.output = FALSE,
                                save.SNN = TRUE, force.recalc = TRUE)
        return(object)
}


sample<- snakemake@wildcards[["sample"]]
data.dir = snakemake@params[["cellranger_count_dir"]]
# Load the seurat_obj dataset
data <- Read10X(data.dir = data.dir)

seurat_obj <- CreateSeuratObject(raw.data = data, min.cells = 3, min.genes = 200, 
    project = sample)

make_seurat_obj_args<- snakemake@params[["make_seurat_obj_args"]]
command<- paste("PreprocessData", "(", "seurat_obj,", make_seurat_obj_args, ")")

seurat_obj<- eval(parse(text=command))

saveRDS(seurat_obj, file = paste0("seurat_objs/", sample, "_seurat.rds"))

run:
	if config['download']:
		shell("source activate py27")
		shell("python scripts/BaseSpaceRunDownloader_v2.py -r {wildcards.run_id}  -a {config[token]} 2> {log}")
	## if not downloaded from baseSpace, soft link the directory 
	else:
		with open(config['run_dirs']) as f:
			reader = csv.reader(f, delimiter = "\t")
			# skipt the header
			header = next(reader)
			run_dir_dict = {}
			for row in reader:
				run_id = row[0].strip()
				run_dir = row[1].strip()
				run_dir_dict[run_id] = run_dir
	# snakemake autocreate the output folder first, I need to remove it first, otherwise ln -s will link to the subfolder
	# of run_id
	cmd1 = "rm -rf {run_id}".format(run_id = wildcards.run_id)			
	cmd2 = "ln -rs {run_dir} {run_id}".format(run_dir = run_dir_dict[wildcards.run_id], run_id = wildcards.run_id)
	shell(cmd1)
	shell(cmd2)