package AdvancedShop;

use Types::Standard qw(Int ArrayRef HashRef);
use Data::Printer;

use MaleCustomer;
use FemaleCustomer;

use Moo;

has seats => ( is => 'ro', isa => Int, required => 1, );

has queue => ( 
    is => 'lazy', 
    isa => ArrayRef[Int],
    builder => sub { [ map 0, 1 .. shift->seats ] }, # this needs to be mutable!!    
);

# hold value of Customer->getRequiredTime(), or 10 if no customer waiting:
has duration  => ( is => 'rw', isa => Int );
# how long left in day after subtraction of each duration value:
has time_left => ( is => 'rw', isa => Int );
# hold revenue taken during day:
has cumulative_revenue => ( 
    is => 'rw', 
    isa => Int, 
    default => 0, 
);
# has Customer => ( is => 'lazy' ); # not sure what this is for
has customers => ( is => 'rw', isa => HashRef, default => sub { {} } ); # internal counter for customers recruited & served

# get total revenue taken at end of day, or end of period for averageRevenue():
sub getTotalRevenue { shift->cumulative_revenue }
sub addRevenue {
    my ($self, $amount) = @_; # p $amount;
    $self->cumulative_revenue( $self->cumulative_revenue + $amount );
}

sub getQueue { shift->queue }

sub addToQueue {
    my ($self, $customer) = @_; # $customer is Customer object
    
    my $que = $self->getQueue; # array of Customer objects

    my $i = 0;
    for (@$que) {
        unless ($_) { # skip non-zero vals
            $que->[$i] = $customer; 
            $self->customers->{ref $customer}->{joined_queue}++;
            return 1; # return 'true'
        }
        $i++;
    }
    return 0; # return 'false'
}

sub removeFromQueue {
    my $self = shift;
    
    my $que = $self->getQueue; # array of Customer objects
    my $o   = shift @$que; # p $o; # a Customer object
    push @$que, 0; # p $que;
    return $o || undef; # returns customer object or null
}

# needs to remove empty seats, or seats with Customer object with wait time < 0:
# uses the served (shifted) Customer getRequiredTime() method to determine expire time
sub expire {
    my ($self, $element) = @_; # element = Customer object or undef - shifted from top of queue

    my $que = $self->getQueue; # array of Customer objects
    my $no_of_seats = $self->seats; # p $no_of_seats; # original array size
    
    # get time value to expire from each element of queue, either getRequiredTime()
    # or 10 minutes:
    my $duration = ref $element
        ? $element->getRequiredTime
        : 10; # p $duration;
    # initialise duration() for use in serveOneCustomer:
    $self->duration($duration); 
    
    if ( $self->time_left ) { # adjust time_left today:
        my $time_left = $self->time_left - $duration;
        $self->time_left($time_left);
    }

    my $i = 0; # initialise array index counter
    # for array position 0 to last index position:
    for ( 0 .. $no_of_seats - 1 ) { # p $i;
        my $seat = $que->[$i]; # p $seat;
        my $t = 0; # set default, maybe updated in block:
        if ( ref $seat ) { # we have a Customer object
            # adjust waiting time to subtract $duration derived above:
            $t = $seat->wait - $duration; # p $seat->wait; # p $t;
            $seat->wait($t);
            # need to adjust for male customer leaving if $duration > 35
            $t = 0 if ref $seat eq 'MaleCustomer' && $duration > 35; # p $t;
        } # p $t;
        # auto-increment counter then test element at index position, if element <=0 remove
        # it and decrement counter as next element now occupies current index position:
        $i++;
        splice @$que, --$i, 1 if $t <= 0;
    } # p $que;
    # append zeros until array grows to original size:
    push @$que, 0 while @$que < $no_of_seats;
}

# return male or female customer at 0.3 : 0.7 frequency
sub arrivingCustomer {
    my $self = shift;    
    
    my $rand = rand(1);
    
    # if rand <= 0.7 (70% of the time) , return female customer with random 
    # (>=20 and <50 ) requiredTime:
    if ( $rand <= 0.7 ) { # female 
        my $t = int rand(29) + 20; # p $t;
        my $o = FemaleCustomer->new( requiredTime => $t );
        return $o;    
    }
    # if rand > 0.7 (30% of the time), return male customer with random
    # (>=30 and <90 ) tolerance:
    else { # male 
        my $t = int rand(59) + 30; # p $t;
        my $o = MaleCustomer->new( tolerance => $t );
        return $o;
    }    
}

sub serveOneCustomer {
    my ($self, $probability) = @_;
    
    # remove 1st element & add zero to end, returns Customer object, or undef:
    my $element = $self->removeFromQueue(); # p $element;
    $self->customers->{ref $element}->{served}++ if ref $element;
    
    # run expire function on queue, if $element is an object exipre getRequiredTime 
    # (if false all queue values must be zero), otherwise 10 minutes; sets 
    # duration():
    $self->expire($element);
    
    my $duration = $self->duration; # p $duration;
    my $que      = $self->getQueue; # p $que; # array of Customer objects

    for ( 1 .. $duration ) { # p $_;
        my $rand = rand(1); # p $rand;
        # add new customer if rand value LESS THAN p value:
        if ( $rand < $probability ) {
            my $new_customer = arrivingCustomer(); # p $new_customer;
            $self->addToQueue($new_customer);
        }
    } # p $self->getQueue;
    # return revenue value of customer served (if any):
    return $element
        ? $element->getPayment
        : 0;
}

sub runDay {
    my ($self, $number_of_minutes, $probability) = @_;
    
    # set duration of day in minutes:
    $self->time_left($number_of_minutes); 
    
    while ( $self->time_left > 0 ) { # p $self->time_left;
        my $revenue = $self->serveOneCustomer($probability); # p $revenue;
        $self->addRevenue($revenue); # p $self->cumulative_revenue;
    }
}

sub averageRevenue {
    my ($self, $number_of_minutes, $number_of_days, $probability) = @_;
    
    for ( 1 .. $number_of_days ) { # p $_;
        # create new instance of self:
        my $o = AdvancedShop->new( seats => $self->seats );
        $o->runDay(480, $probability);
        my $revenue_for_day = $o->getTotalRevenue; # p $revenue_for_day;
        # add daily revenue to outer (parent) object, not local instance:
        $self->addRevenue($revenue_for_day);
        my $customers = $o->customers;
        # add customer counters to outer object:
        while ( my ($type, $d) = each %$customers ) {
            $self->customers->{$type}->{$_} += $d->{$_} for keys %$d;
        }
    }
    return sprintf '%.02f', $self->getTotalRevenue / $number_of_days;
}

1;