package Exception;

use warnings;
use strict;

# Enable Perl 6 knock offs.
use 5.010;

use Carp;
use Exporter 'import';
our @EXPORT_OK = qw(create_exception delete_exception);

# Global stores for all exceptions.
# NOTE: In this module each exception is just a Exception class,
# and not it's own class; instead the data about each exception is created with
# create_exception() and destroyed with delete_exception() while being stored in
# %exception_{desc,param}.
state %exception_desc;
state %exception_param;
# It is a hash of hashes.  Each key in the first hash is the name or type of
# exception, while the key in the second hash is 'description' for the type's
# description, or 'params' for the list of parameters that  exception takes.

# Constructs new Exception objects in order to throw exceptions
# coupled with die.  For example:
# die Exception->throw('SomeException');
sub throw {
    my($class, $exception_type, @params) = @_;
        croak <<EOC unless exception_exists($exception_type);
You tried to throw an exception [$exception_type] that does not exist, or has
not been declared.  You must define every exception before you try to throw that
exception.
EOC

    # Build object now for use below.
    my $self = bless {_exception_type => $exception_type,
              _description => $exception_desc{$exception_type} }, $class;

    # shift off the name of the parameter.
    while (defined(my $param = shift @params)) {
        if (grep $param eq $_, @{$exception_param{$exception_type}}) {
            # Store parameter inside this exception object.
            $self->{$param} = (shift @params // croak <<EOC);
You tried to throw an exception that had an uneven number of parameters and
their values.  The list of parameters you provide must be an even number of
parameters followed by their values as in a hash. (ex: 'exception' a => '1', b
=> '2', c => '3')
EOC
            # Also, substitute this paramter for its value in this exception's
            # description.
            #BUGALERT# be sure to test that this actually works.
            $self->{_description} =~ s/$param/$self->{$param}/g;
        } else {
            croak <<EOC;
You tried to throw an exception with a paramter that the exception does not
accept.  Your parameters [@params].  Accepted parameters
[@{$exception_param{$exception_type}}].
EOC
        }
    }

    return $self;
}

# A subroutine to be optionally exported by Exception that adds
# entries to %exception thereby creating new exceptions.  Each class that throws
# exceptions must call this subroutine first to create those exceptions.
sub create_exception {
    my ($exception_type, $description, @params) = @_;
    if (exception_exists($exception_type)) {
        warn <<EOW;
You have redefined an exception.  This might be an error, because they should
really only be defined just once.
EOW
    }

    # Add this new exception to %exception_{desc,param}.
    $exception_desc{$exception_type} = $description,
    $exception_param{$exception_type} = [@params];
}

# Checks to see if a given exception exists or not.
sub exception_exists {
    my $exception_type = shift;
    if (exists $exception_desc{$exception_type} and
        exists $exception_param{$exception_type} ) {
        return "$exception_type exists!"; #return true
    } else {
        return 0; #return false
    }
}

1;