# -*- ruby -*-

#encoding: utf-8

require 'loggability'

require 'configurability'

require 'sequel'

require 'strelka'

require 'strelka/mixins'

require 'thingfish'

require 'thingfish/mixins'

require 'thingfish/metastore'

# Toplevel namespace

class Thingfish::Metastore::PgGraph < Thingfish::Metastore

	extend Loggability,

	       Configurability,

	       Strelka::MethodUtilities

	include Thingfish::Normalization

	# Load Sequel extensions/plugins

	Sequel.extension :migration

	# Package version

	VERSION = '0.1.0'

	# Version control revision

	REVISION = %q$Revision$

	# The data directory that contains migration files.

	#

	DATADIR = if ENV['THINGFISH_METASTORE_PGGRAPH_DATADIR']

			Pathname.new( ENV['THINGFISH_METASTORE_PGGRAPH_DATADIR'] )

		elsif Gem.datadir( 'thingfish-metastore-pggraph' )

			Pathname.new( Gem.datadir('thingfish-metastore-pggraph') )

		else

			Pathname.new( __FILE__ ).dirname.parent.parent.parent +

				'data' + 'thingfish-metastore-pggraph'

		end

	# The default config values

	DEFAULT_CONFIG = {

		uri: 'postgres:/thingfish',

		slow_query_seconds: 0.01,

	}

	# Loggability API -- use a separate logger

	log_as :thingfish_metastore_pggraph

	# Configurability API -- load the `pg_metastore`

	config_key :pggraph_metastore

	##

	# The URI of the database to use for the metastore

	singleton_attr_accessor :uri

	##

	# The Sequel::Database that's used to access the metastore tables

	singleton_attr_accessor :db

	##

	# The number of seconds to consider a "slow" query

	singleton_attr_accessor :slow_query_seconds

	### Set up the metastore database and migrate to the latest version.

	def self::setup_database

		Sequel.extension :pg_json_ops

		self.db = Sequel.connect( self.uri )

		self.db.logger = Loggability[ Thingfish::Metastore::PgGraph ]

		self.db.extension :pg_streaming

		self.db.stream_all_queries = true

		self.db.optimize_model_load = true

		self.db.sql_log_level = :debug

		self.db.extension( :pg_json )

		self.db.log_warn_duration = self.slow_query_seconds

		# Ensure the database is current.

		#

		unless Sequel::Migrator.is_current?( self.db, self.migrations_dir.to_s )

			self.log.info "Installing database schema..."

			Sequel::Migrator.apply( self.db, self.migrations_dir.to_s )

		end

	end

	### Tear down the configured metastore database.

	def self::teardown_database

		self.log.info "Tearing down database schema..."

		Sequel::Migrator.apply( self.db, self.migrations_dir.to_s, 0 )

	end

	### Return the current database migrations directory as a Pathname

	def self::migrations_dir

		return DATADIR + 'migrations'

	end

	### Configurability API -- set up the metastore with the `pg_metastore` section of

	### the config file.

	def self::configure( config=nil )

		config = self.defaults.merge( config || {} )

		self.uri                = config[:uri]

		self.slow_query_seconds = config[:slow_query_seconds]

		self.setup_database

	end

	### Set up the metastore.

	def initialize( * ) # :notnew:

		require 'thingfish/metastore/pggraph/node'

		require 'thingfish/metastore/pggraph/edge'

		Thingfish::Metastore::PgGraph::Node.db = self.class.db

		Thingfish::Metastore::PgGraph::Edge.db = self.class.db

		@model = Thingfish::Metastore::PgGraph::Node

	end

	######

	public

	######

	##

	# The Sequel model representing the metadata rows.

	attr_reader :model

	#

	# :section: Thingfish::Metastore API

	#

	### Return an Array of all stored oids.

	def oids

		return self.each_oid.to_a

	end

	### Iterate over each of the store's oids, yielding to the block if one is given

	### or returning an Enumerator if one is not.

	def each_oid( &block )

		return self.model.select_map( :id ).each( &block )

	end

	### Save the +metadata+ Hash for the specified +oid+.

	def save( oid, metadata )

		md = self.model.from_hash( metadata )

		md.id = oid

		md.save

	end

	### Fetch the data corresponding to the given +oid+ as a Hash-ish object.

	def fetch( oid, *keys )

		metadata = self.model[ oid ] or return nil

		if keys.empty?

			return metadata.to_hash

		else

			keys = normalize_keys( keys )

			values = metadata.to_hash.values_at( *keys )

			return Hash[ [keys, values].transpose ]

		end

	end

	### Fetch the value of the metadata associated with the given +key+ for the

	### specified +oid+.

	def fetch_value( oid, key )

		metadata = self.model[ oid ] or return nil

		return metadata.send( key )

	end

	### Fetch UUIDs related to the given +oid+.

	def fetch_related_oids( oid )

		oid = normalize_oid( oid )

		oid = self.model[ oid ]

		return [] unless oid

		return oid.related_nodes.map( &:id_c )

	end

	### Search the metastore for UUIDs which match the specified +criteria+ and

	### return them as an iterator.

	def search( options={} )

		ds = self.model.naked.select( :id )

		self.log.debug "Starting search with %p" % [ ds ]

		ds = self.omit_related_resources( ds, options )

		ds = self.apply_search_criteria( ds, options )

		ds = self.apply_search_order( ds, options )

		ds = self.apply_search_direction( ds, options )

		ds = self.apply_search_limit( ds, options )

		return ds.map {|row| row[:id] }

	end

	### Update the metadata for the given +oid+ with the specified +values+ hash.

	def merge( oid, values )

		values = normalize_keys( values )

		md = self.model[ oid ] or return nil

		md.merge!( values )

		md.save

	end

	### Remove all metadata associated with +oid+ from the Metastore.

	def remove( oid, *keys )

		self.model[ id: oid ].destroy

	end

	### Remove all metadata associated with +oid+ except for the specified +keys+.

	def remove_except( oid, *keys )

		keys = normalize_keys( keys )

		md = self.model[ oid ] or return nil

		md.user_metadata.keep_if {|key,_| keys.include?(key) }

		md.save

	end

	### Returns +true+ if the metastore has metadata associated with the specified +oid+.

	def include?( oid )

		return self.model.count( id: oid ).nonzero?

	end

	### Returns the number of objects the store contains.

	def size

		return self.model.count

	end

	#########

	protected

	#########

	### Omit related resources from the search dataset +ds+ unless the given

	### +options+ specify otherwise.

	def omit_related_resources( ds, options )

		unless options[:include_related]

			self.log.debug "  omitting entries for related resources"

			ds = ds.unrelated

		end

		return ds

	end

	### Apply the search :criteria from the specified +options+ to the collection

	### in +ds+ and return the modified dataset.

	def apply_search_criteria( ds, options )

		if (( criteria = options[:criteria] ))

			criteria.each do |field, value|

				self.log.debug "  applying criteria: %p => %p" % [ field.to_s, value ]

				ds = ds.where_metadata( field => value )

			end

		end

		return ds

	end

	### Apply the search :order from the specified +options+ to the collection in

	### +ds+ and return the modified dataset.

	def apply_search_order( ds, options )

		if options[:order]

			columns = Array( options[:order] )

			ds = ds.order( columns.map(&:to_sym) )

		end

		return ds

	end

	### Apply the search :direction from the specified +options+ to the collection

	### in +ds+ and return the modified dataset.

	def apply_search_direction( ds, options )

		ds = ds.reverse if options[:direction] && options[:direction] == 'desc'

		return ds

	end

	### Apply the search :limit from the specified +options+ to the collection in

	### +ds+ and return the modified dataset.

	def apply_search_limit( ds, options )

		if (( limit = options[:limit] ))

			self.log.debug "  limiting to %s results" % [ limit ]

			offset = options[:offset] || 0

			ds = ds.limit( limit, offset )

		end

		return ds

	end

end # class Thingfish::Metastore::PgGraph