use strict;

package IMPL::SQL::Schema::Column;

use IMPL::lang qw( :base :compare :hash );
use IMPL::Exception();
use IMPL::Const qw(:prop);
use IMPL::declare {
	require => {
		SchemaType => '-IMPL::SQL::Schema::Type'
	},
	base => [
		'IMPL::Object'           => undef,
	],
	props => [
		name         => PROP_RO | PROP_DIRECT,
		type         => PROP_RO | PROP_DIRECT,
		isNullable   => PROP_RO | PROP_DIRECT,
		defaultValue => PROP_RO | PROP_DIRECT,
		tag          => PROP_RO | PROP_DIRECT
	]
};

sub CTOR {
	my ( $this, %args ) = @_;

	$this->$_( $args{$_} )
	  foreach grep exists $args{$_}, qw( name type isNullable defaultValue tag);

	$this->{$name} or
	  die new IMPL::InvalidArgumentException('A column name is required');

	$this->{$isNullable} ||= 0;    # if not exists $this->{$isNullable};

	is( $this->{$type}, SchemaType )
	  or die new IMPL::InvalidArgumentException(
		'a type is required for the column',
		$this->{$name} );
}

sub SameValue {
	my ( $this, $other ) = @_;

	return (  $this->{$name} eq $other->{$name}
		  and $this->{$isNullable} == $other->{$isNullable}
		  and equals_s( $this->{$defaultValue}, $other->{$defaultValue} )
		  and $this->{$type}->SameValue( $other->{$type} ) );
}

sub SetType {
	my ( $this, $newType ) = @_;

	$this->{$type} = $newType;
}

sub SetDefaultValue {
	my ( $this, $value ) = @_;

	$this->{$defaultValue} = $value;
}

sub SetNullable {
	my ( $this, $value ) = @_;

	$this->{$isNullable} = $value;
}

sub SetOptions {
	my ( $this, $diff ) = @_;

	return unless ref $diff eq 'HASH';

	$this->tag( {} ) unless $this->tag;

	hashApply( $this->tag, $diff );
}

1;