class DeviceService

	include Singleton

	# Public: Returns an Sso::DeviceRegistrationToken created for the particular user.
	#
	def generate_device_registration_token(user_id)
		Sso::DeviceRegistrationToken.create!(message: { user_id: user_id }.to_json, expiration: Sso::DeviceRegistrationToken::EXPIRATION_IN_MINUTES.minutes.from_now)
	end

	def registered_devices(user_id)
		OAuth::Device.where(user_id: user_id)
	end

	def register_device(device_id, device_family, device_name, device_type, user_id, data, app_version, replication: true)

		output = Hash.new
		output[:success] = true
		device = OAuth::Device.create!(
				:app_version => app_version,
				:data => data,
				:device_family => device_family,
				:device_id => device_id,
				:device_name => device_name,
				:device_type => device_type,
				:user_id => user_id
				)

		debug { "Created device having #{device.to_json}" }

		begin
			debug { "Creating couch db for user #{user_id}" }

			result = Couch::CouchStoreService.create_database("#{COUCH_DB_CONFIG['replica_prefix']}#{device_id}", replication: replication)
			debug { "CouchDB creation result ==> #{result}" }

			if result.nil? #Error creating couch database
				raise "Error creating couch database for user #{user_id} having device id #{device_id}"
			else
				# Adding user to couch
				debug { "Adding couch user to CouchDB #{COUCH_DB_CONFIG['replica_prefix']}#{device_id}" }

				response = Couch::CouchStoreService.create_user(
					device_id: device.device_id,
					password: device.couch_password,
					consumer_token: device.key,
					consumer_secret: device.secret,
					token: device.token,
					token_secret: device.token_secret,
					database: COUCH_DB_CONFIG['replica_prefix'] + device_id
					)
				debug { "CouchDB user creation result ==> #{response}" }
				if response["ok"]
					device_hash = device.as_json
					device_hash["device"]["device_logging_enabled"] = Pundit.policy!(User.find(user_id), :device).device_logging_enabled?
					output[:result] = device_hash
				end
			end
		rescue StandardError => e
			unregister_device(device.device_id, device.device_type, user_id, replication)
			output[:success] = false
			output[:errors] = ["Error creating couch database for user #{user_id} having device id #{device_id}"]
			Rails.logger.error e
			ExceptionService.notify(e)
		end
		output
	end

	def unregister_device(device_id, device_type, user_id, replication: true)
		begin
			OAuth::Device.where(device_id: device_id, user_id: user_id).delete_all

			result = Couch::CouchStoreService.drop_database(device_id, replication)
			raise "Error deleting couch database #{device_id}" unless result
			remove_job_requests(device_id, user_id)

			"Successfully unregistered device"
		rescue StandardError => e
			message = "An exception has occurred while trying to unregister device #{device_id} for user #{user_id}"
			Rails.logger.error(message)
			Rails.logger.error(e)
			ExceptionService.notify(e)
		end
	end

	def remove_job_requests(device_id, user_id)
		user = User.find user_id
		key = "Sync_#{device_id}_"
		job_aliases = user.courses.map{ |c| key + c.id.to_s }
		JobRequest.where(:job_alias_name => job_aliases).destroy_all
	end

	def sync_course_on_device(course_id, device_id, device_type)

		job_alias_name = "Sync_#{device_id}_#{course_id}"
		result = JobRequest.where(:job_alias_name => job_alias_name)
		if result.empty?
			job_execution_context = Hash.new
			job_execution_context["course_id"] = course_id
			job_execution_context["device_id"] = device_id
			job_execution_context["device_type"] = device_type

			jr = JobRequest.create!({ job_name: SecureRandom.hex(16), job_alias_name: job_alias_name, job_enabled: true, recurring: false, job_arguments: job_execution_context.to_json, job_type: JobRequest::COUCH_SYNC_TYPE, cron: JobRequest::NO_CRON })
			JobExecution.create!(job_request_id: jr.id, start_time: Time.now, status: JobRequest::WIP)
			CouchCourseSyncWorker.perform_async(jr.id.to_s)
		end
	end

	private

	def debug(&block)
		Rails.logger.tagged(self.class.name) { Rails.logger.debug(&block) }
	end

end