"""
	Features :
		- data collection
		- detection, reboot	(service)
		- respond to commands	(service)
"""
#from threading import Thread, RLock
from __future__ import division
import os
import json
import time
from datetime import datetime
from utils.transport import *
import monitor
import requests
class Manager() :
	def version(self):
		return 1.1
	"""
		
		delay : <value>
		limit : <value>
		scope : apps,folders,learner,sandbox
	"""
	def __init__(self):
		self.factory	= DataSourceFactory()
	def set(self,name,value):
		setattr(name,value)
	def init(self,**args) :
		self.id		= args['node']
		self.agents 	= args['agents']
		self.config	= dict(args['config'])
		self.key	= args['key']
		self.actors	= args['actors']
		self.plan	= self.config['plan']
		
		self.DELAY  = int(self.plan['metadata']['delay'])
		
		self.update()	#-- Initializing status information

	def update(self) :
		"""
			This method inspect the plans for the current account and makes sure it can/should proceed
			The user must be subscribed and to the service otherwise this is not going to work
		"""
		# url="https://the-phi.com/store/status/monitor"
		# r = requests.get(url,headers={"uid":self.key})
		# plans = json.loads(r.text)
		# meta =  [item['metadata'] for item in plans if item['status']=='active' ]
		
		meta = self.plan['metadata']
		
		if meta :
			self.DELAY = 60* int(meta['delay'])
			self.LIMIT = int(meta['limit'])
			#dbname = [item['name'] for item in plans if int(item['metadata']['limit']) == self.LIMIT][0]
			#self.config['store']['args']['dbname'] = dbname

		else:
			self.DELAY = -1
			self.LIMIT = -1
	
		#self.filter(meta)
		
		self.agents  = self.filter('agents',meta,self.agents)
		self.actors = self.filter('actors',meta,self.actors)
		#self.setup(meta)

	def filter_collectors(self,meta) :
		"""
			remove collectors that are not specified by the plan
			Note that the agents (collectors) have already been initialized ?
		"""
		values = meta['agents'].replace(' ','').split(',')
		self.agents = [agent for agent in self.agents if agent.getName() in values]

		
	def filter_actors(self,meta):
		"""
			removes actors that are NOT specified by the subscription plan
			Note that the actor have already been instatiated and need initialization
		"""
		values = meta['actors'].replace(' ','').split('.')
		self.actors = [actor for actor in self.actors if actor.getName() in values]
	
	def filter(self,id,meta,objects):
		values = meta[id].replace(' ','').split(',')
		return [item for item in objects if item.getName() in values]
	def __filter(self,meta) :
		scope = []
		lactors= []
		for item in meta :
			scope = scope + item['scope'].split(',')
			if 'actors' in item :
				lactors= lactors + item['actors'].split(',')
		self.agents = [agent for agent in self.agents if agent.getName() in scope]
		if len(lactors) == 0 :
			self.actors = []
		self.actors = [ actor for actor in self.actors if actor.getIdentifier() in lactors]
		if len(self.actors) > 0 :
			#
			# We should configure the actors accordingly and make sure they are operational
			#
			
			conf = {"apps":None}
			#
			# We need to get the configuration for the apps remotely
			# 
			read_class 	= self.config['store']['class']['read']
			read_args	= self.config['store']['args']
			couchdb	= self.factory.instance(type=read_class,args=read_args)
			uinfo 	= couchdb.view('config/apps',key=self.key)
			if 'apps' in uinfo :
				conf['apps'] = uinfo['apps']
			#
			# Threshold will always give a default value
			#
			info = couchdb.view('config/folders',key=self.key)
			threshold = info
			conf['folder_threshold'] = threshold

			mailer = None
			for actor in self.actors :
				id = actor.getIdentifier()
				if id == "mailer" :
					mailer = actor.Mailer()
				if conf[id] is None :
					continue
				args = conf[id]
				actor.init(args)
			#
			# Initializing the mailer
			if mailer is not None and mailer in self.config:
				mailer.init(self.config['mailer'])
			
		return meta
	def setup(self,meta) :
		conf = {"folders":None,"apps":None}
		read_class 	= self.config['store']['class']['read']
		read_args	= self.config['store']['args']
		

		couchdb	= self.factory.instance(type=read_class,args=read_args)
		args 	= couchdb.view('config/apps',key=self.key)
		if len(args.keys()) > 0 :
			self.apply_setup('apps',args)
		args = couchdb.view('config/folders',key=self.key)
		
		if 'folder_size' not in meta :
			args['threshold'] = meta['folder_size']
		self.apply_setup('folders',args)			
			
	def apply_setup(self,name,args) :
		for actor in self.actors :
			if args is not None and actor.getName() == name and len(args.keys()) > 0:								
				actor.init(args)

		
	def __setup(self,meta):
		#
		# We should configure the actors accordingly and make sure they are operational
		#
		conf = {"folders":meta['folder_threshold'],"apps":None}
		#
		# We need to get the configuration for the apps remotely
		# 
		read_class 	= self.config['store']['class']['read']
		read_args	= self.config['store']['args']
		
		couchdb	= self.factory.instance(type=read_class,args=read_args)
		uinfo 	= couchdb.view('config/apps',key=self.key)
		if 'apps' in uinfo :
			conf['apps'] = uinfo['apps']
		
		for agent in self.agents :
			agent.init(conf['apps'])

		mailer = None
		for actor in self.actors :
			id = actor.getIdentifier()
			if id == "mailer" :
				mailer = actor.Mailer()
			if conf[id] is None :
				continue
			args = conf[id]
			actor.init(args)
		#
		# Initializing the mailer
		if mailer is not None and mailer in self.config:
			mailer.init(self.config['mailer'])
				
	def isvalid(self):
		self.update()
		return self.DELAY > -1 and self.LIMIT > -1
	def post(self,row) :
		"""
			This function is designed to take appropriate action if a particular incident has been detected
			@param label	
			@param row	data pulled extracted
		"""
		message = {}
		message['action'] = 'reboot'
		message['node']	= label

	def callback(self,channel,method,header,stream):
		"""
			This function enables the manager to be able to receive messages and delegate them to the appropriate actor
			@channel
		"""
		print [channel,header]
		message = json.loads(stream)
		data = message['data']

	def run(self):
		#DELAY=35*60 #- 35 Minutes
		#LIMIT=1000
		COUNT = 0
		COUNT_STOP 	= int(24*60/ self.DELAY)
		write_class	= self.config['store']['class']['write']
		read_args	= self.config['store']['args']
		while True :
			COUNT += 1
			if COUNT > COUNT_STOP :
				if self.isvalid() :
					COUNT = 0
				else:
					break
			for agent in self.agents :
				data	= agent.composite()
				label	= agent.getName()
				node	= '@'.join([label,self.id])
				row		= {}
				if label == 'folders':
					row = [ dict({"id":self.id}, **_row) for _row in data]					
					
				else:
					#label = id
					row = data
				if type(row)==list and len(row) == 0 :
					continue
					
				#
				#
				index = self.agents.index(agent)

				if len(self.actors) > index and self.actors[index].getName() == agent.getName() :
					actor = self.actors[index]
					print actor.analyze(row)

				# self.lock.acquire()
				store = self.factory.instance(type=write_class,args=read_args)
				store.flush(size=self.LIMIT)
				store.write(label=node,row=row)
				# self.lock.release()
			time.sleep(self.DELAY)