#!/usr/bin/perl

use strict;

our $RELAY_OFFENSIVE_RE = '(fags?|faggots?|niggers?|cunts?|homos?|trannys?|trannies?)';
our $RELAY_PERSONAL_RE  = '(skrenta|blekko|(thomas|tom) markson)';

our $point = 0;
our %players = {'dealer' => [10000000000,0,0]};
our $bet = 0;
sub do_craps {
    my ( $conn ) = @_;
    $players{$conn->{user}} = [1000,0,0];
    tmp_no_rotty( $conn );

    my $n = craps_nusers();
    $n++;

    my $footer_first = [];

    if ( $n == 1 ) {
        push @$footer_first, "There is $n user at this craps table.";
    } else {
        push @$footer_first, "There are $n users at this craps table.";
    }

    my $footer = [];
    push @$footer, '[' . join( ' ', @$footer_first ) . ']';

    my $udata = $conn->{udata};

    push @$footer, '[Type /help to list all commands, /quit to quit]';

    println( join( "\n", @$footer ) );

    $conn->{in_craps} = 1;
    $conn->{interrupt_sub} = \& craps_finish;

    my $last_craps = $conn->{udata}->{last_craps};

    if ( defined $last_craps ) {
        craps_announce( '%' . "$conn->{user} entered (" . delta_time( $last_craps, 1 ) . ")", undef, $conn->{user} );
    } else {
            craps_announce( '%' . "$conn->{user} entered", undef, $conn->{user} );
    }

    $conn->{udata}->{last_craps} = time;
    return \& craps_loop;
}

sub do_craps_cli {
    my ( $conn ) = @_;

    my $user = $conn->{user};
    my $msg = $conn->{arg};

    if ( $conn->{options} ) {
        my @options = keys %{ $conn->{options} };
        my $option = shift @options;
        $option .= '  ' . $msg if $msg ne '';
        return craps_command( $conn, $option );
    }
    return;
}

sub craps_loop {
    my ( $conn ) = @_;

    delete $conn->{grep};

    $conn->{interrupt_sub} = \& craps_finish;

    $conn->{readline_no_cr} = 1;
    $conn->{readline_no_empty_return} = 1;

    my $line = th_readline( '>' );

    return sub {
        my $msg = $$line;

        $msg = clean_string2($msg);

        $conn->{interrupt_sub} = \& craps_finish;
        delete $conn->{relay_systat};

        if ( $msg =~ m,^/(.*)$, ) {
            return craps_command( $conn, "$1" );
        } elsif ( $msg =~ m,^(\?)$, ) {
            return craps_command( $conn, "$1" );
        } else {
# TODO remove the "/" requirement for commands since there is no chat

            my $user = $conn->{user};

            if ( $msg ne '' && ! is_robot($conn) ) {
                $user = uc $user if $conn->{tty};
                craps_announce( "dealer: /? for help", undef, $conn->{user} );
                $conn->{udata}->{last_craps} = time;
            }
        }
        return \& craps_loop;
    }
}

sub craps_command {
    my ( $conn, $cmd ) = @_;

    my $arg;
    my $arg2;

    if ( ! $conn->{bg_relay} ) {
        $conn->{interrupt_sub} = \& craps_finish;
    }

    if ( $cmd =~ /^([^\s]+)\s+(.+)$/ ) {
        $cmd = $1;
        $arg = $2;
    }
    my $rest = $arg;

    if ( $arg =~ /^([^\s]+)\s+(.+)$/ ) {
        $arg = $1;
        $arg2 = $2;
    }

    $arg =~ s/\s+$//;
    $arg2 =~ s/\s+$//;

    $cmd =~ s/\s$//;
    my $orig_cmd = $cmd;
    $cmd = lc $cmd;

    $conn->{arg} = $arg;
    $conn->{arg2} = $arg2;

    if ( $cmd =~ m,^(quit|exit|bye)$,i ) {
        if ( defined $conn->{spoof_fd} ) {
            craps_finish( $TH::conns->{ $conn->{spoof_fd} }, 0 );
            return \& craps_loop;
        } else {
            println() if ! $conn->{bg_relay};
            craps_finish($conn);
            return;
        }
    }

    if ( $cmd eq 'help' || $cmd eq '?' ) {
        println() if ! $conn->{bg_relay};

        my @rhelp =
        (
            "/clear       clear screen",
            "/help        print this message",
            "/afk         away from keyboard",
            "/quit        exit relay",
            "/roll        roll dice",
            "/bet <#>     place a passline bet, default and minimum is 5, increments must be of 5",
            "/add         add odds to your passline bet",
            "/reduce      reduce your odds",
            "/rail        show what you have on the rail",
            "/table       show what you have on the table",
            "/s           relax and take a sip",
            "/y           take a big stretch and yawn",
            "/w           systat",
            "/who         who's playing craps",
        );

        $conn->{func_next} = \& craps_loop;
        return pager( \@rhelp );
    }

    if ( $cmd eq 'w' || $cmd eq 'systat' || $cmd eq 'finger' ) {
        println() if ! $conn->{bg_relay};
        delete $conn->{relay_systat};
        $conn->{func_next} = \& craps_loop;
        return \& do_finger;
    }

    if ( $cmd eq 'who' ) {
        println() if ! $conn->{bg_relay};
        $conn->{func_next} = \& craps_loop;
        $conn->{relay_systat} = 1;
        return \& do_finger;
    }

    if ( $cmd eq 'clear' || $cmd eq 'cls' ) {
        #println() if ! $conn->{bg_relay};

        $conn->{func_next} = \& craps_loop;
        return \& do_clear;
    }

    if ( $cmd eq 'bet'){
        $bet = 5;
        if ($rest){
            $bet = int($rest);
            if ($bet == 0){
                $bet = 5;
            }
        }
        $players{$conn->{user}}[1] = $bet;
        $players{$conn->{user}}[0] -= $bet;
        craps_announce("$conn->{user} bets: $bet", undef, $conn->{user});
        return \& craps_loop;
    }

    if ( $cmd eq 'add'){
        $bet = $players{$conn->{user}}[1] * 3;
        $players{$conn->{user}}[0] -= $bet;
        $players{$conn->{user}}[2] = $bet;
        craps_announce("$conn->{user} places odds of $players{$conn->{user}}[2]", undef, $conn->{user});
        return \& craps_loop;
    }

    if ( $cmd eq 'rail'){
        craps_announce("$conn->{user}: $players{$conn->{user}}[0]");
        return \& craps_loop;
    }

    if ( $cmd eq 'table'){
        craps_announce("$conn->{user}: $players{$conn->{user}}[1] to place", undef, $conn->{user});
        craps_announce("$conn->{user}: $players{$conn->{user}}[2] odds", undef, $conn->{user});
        return \& craps_loop;
    }

    if ( $cmd eq 'roll' || $cmd eq 'dice' || $cmd eq 'r' ) {
        #println() if ! $conn->{bg_relay};
        if ( $players{$conn->{user}}[1] == 0 ) {
            craps_announce("dealer: Please place a passline bet before you roll", undef, $conn->{user});
            return \& craps_loop;
        }
        $conn->{func_next} = \& craps_loop;
        my $die1 = randint( 1, 6 );
        my $die2 = randint( 1, 6 );
        my $roll = $die1 + $die2;
        my $rollmsg = "";
        if ($roll == 2){
            $rollmsg = "two craps, two";
            if ($point == 0){
                crap_out();
            }
        } elsif ($roll == 3){
            $rollmsg = "three craps, three";
            if ($point == 0){
                crap_out();
            }
        } elsif ($roll == 4){
            $rollmsg = "four";
            if ($point == 0){
                $point = 4;
            } elsif ($point == 4){
                $rollmsg = "four, winner four";
                payout();
            }
        } elsif ($roll == 5){
            $rollmsg = "five";
            if ($point == 0){
                $point = 5;
            } elsif ($point == 5){
                $rollmsg = "five, winner five";
                payout();
            }
        } elsif ($roll ==6){
            $rollmsg = "six";
            if ($point == 0){
                $point = 6;
            } elsif ($point == 6){
                $rollmsg = "six, winner six";
                payout();
            }
        } elsif ($roll == 7){
            $rollmsg = "seven";
            if ($point == 0){
                $rollmsg = "seven, winner seven";
                payout();
            } else {
                $rollmsg = "seven out, line away";
                crap_out();
            }
        } elsif ($roll == 8){
            $rollmsg = "eight";
            if ($point == 0){
                $point = 8;
            } elsif ($point == 8){
                $rollmsg = "eight, winner eight";
                payout();
            }
        } elsif ($roll == 9){
            $rollmsg = "nine";
            if ($point == 0){
                $point = 9;
            } elsif ($point == 9){
                $rollmsg = "nine, winner nine";
                payout();
            }
        } elsif ($roll == 10){
            $rollmsg = "ten";
            if ($point == 0){
                $point = 10;
            } elsif ($point == 10){
                $rollmsg = "ten, winner ten";
                payout();
            }
        } elsif ($roll == 11){
            $rollmsg = "eleven";
            if ($point == 0){
                $rollmsg = "eleven, winner eleven";
                payout();
            } else {
                $rollmsg = "eleven, yo eleven";
            }
        } else {
            $rollmsg = "twelve";
            if ($point == 0){
                $rollmsg = "twelve, craps twelve";
                crap_out();
            } else {
                $rollmsg = "boxcars";
            }
        }

        craps_announce( "%$conn->{user} rolled: $die1 $die2 -> $rollmsg -> point is $point", undef, $conn->{user} );

        return \& craps_loop;
    }

    if ( $cmd eq 'me' ) {
        if ( $rest ne '' ) {
            my $user = $conn->{user};
            $user = uc $user if $orig_cmd eq 'ME';

            if ( $rest eq 'poots' || $rest eq 'POOTS' ){
            }
            elsif ( $rest =~ /^doot/i ){
                craps_announce( '* ' . $user . ' ' . $rest, undef, $conn->{user} );
            }
            elsif ( $rest =~ /^tood/i ){
                craps_announce( '* ' . $user . ' ' . $rest, undef, $conn->{user} );
            } else {
                craps_announce( '* ' . $user . ' ' . $rest, undef, $conn->{user} );
            }
        } else {
            println() if ! $conn->{bg_relay};
        }
        return \& craps_loop;
    }

    if ( $cmd eq 's' ) {
        $rest = " $rest" if $rest ne '';
        my $user = $conn->{user};
        my $sips = 'sips';
        $user = uc $user if $orig_cmd eq 'S';
        $sips = uc $sips if $orig_cmd eq 'S';
        craps_announce( "* $user $sips" . $rest, undef, $conn->{user} );
        return \& craps_loop;
    }

    if ( $cmd eq 'y' ) {
        my $yawn = 'yawns';
        my $user = $conn->{user};
        $rest = " $rest" if $rest ne '';
        $user = uc $user if $orig_cmd eq 'Y';
        $yawn = uc $yawn if $orig_cmd eq 'Y';
        craps_announce( "* $user $yawn" . $rest, undef, $conn->{user} );
        return \& craps_loop;
    }

    if ( $cmd eq 'afk' ) {
        $rest = " $rest" if $rest ne '';
        craps_announce( '* ' . $conn->{user} . ' is AFK' . $rest, undef, $conn->{user} );
        return \& craps_loop;
    }

    if ( $cmd eq 'mes' ) {
        if ( $rest ne '' ) {
            my $user = $conn->{user};
            $user = uc $user if $orig_cmd eq 'MES';
            if ( $conn->{user} =~ /s$/ ) {
                craps_announce( '* ' . $user . "' " . $rest, undef, $conn->{user} );
            } else {
                craps_announce( '* ' . $user . "'s " . $rest, undef, $conn->{user} );
            }
        }
        return \& craps_loop;
    }

    println() if ! $conn->{bg_relay} && ! defined $conn->{spoof_fd};
    error( 'unrecognized craps command - type /help for a list' );
    return \& craps_loop;
}

sub crap_out{
    my $k;
    my $v;
    while (($k,$v) = each %players){
        $players{$k}[1] = 0;
        $players{$k}[2] = 0;
    }
    $point = 0;
    return \& craps_loop;
}

sub payout{
    my $k;
    my $v;
    while (($k,$v) = each %players){
        $players{$k}[0] += ( $players{$k}[1] * 2 );
        $players{$k}[0] += ( $players{$k}[2] * 3 );
        $players{$k}[1] = 0;
        $players{$k}[2] = 0;
    }
    $point = 0;
    return \& craps_loop;
}
sub craps_finish {
    my ( $conn, $noannounce ) = @_;

    delete $conn->{interrupt_sub};
    delete $conn->{in_craps};
    delete $conn->{bg_relay};
    delete $conn->{relay_systat};
    clear_readline($conn);

    if ( ! defined $noannounce ) {
        #$noannounce = 1 if ( time - $conn->{last} > 3600 );  # don't notify of exit if > 1h idle
        my ( $n_other_logins, $oldest ) = n_user_relay_logins( $conn->{user}, $conn->{fd} );
        $oldest = time - $oldest;
        $noannounce = 1 if ( $n_other_logins > 0 && $oldest < 3600 );
        #$noannounce = 1 if $conn->{autouser};
    }

    if ( ! $noannounce ) {
        craps_announce( '%' . "$conn->{user} exited", undef, $conn->{user} );
    } else {
    }
}

sub n_user_relay_logins
{
    my ( $user, $skip ) = @_;

    my $count;
    my $last;

    foreach my $port ( keys %{ $TH::conns } ) {
        my $c = $TH::conns->{$port};
        next if ! $c->{in_craps};
        next if $port == $skip;
        next if $c->{user} ne $user;
        $count++;
        $last = $c->{last} if !defined $last || $c->{last} < $last;
    }

    return ( $count, $last ) if wantarray;
    return $count;
}

our %relay_last_message;
our %relay_duplicate_count;

our %relay_last_interval;
our %relay_interval_count;

sub craps_announce {
    my ( $msg, $skip, $user ) = @_;

    # suppress backgrounded relay messages from rotty
    my $rotty_tmp = $TH::rotty_users;
    $TH::rotty_users = undef;

    my $conn = get_conn();

    if ( $relay_last_message{ $user } ne $msg || $msg =~ /^%/ ) {
        delete $relay_duplicate_count{ $user };
        $relay_last_message{ $user } = $msg;
    }
    $relay_duplicate_count{ $user }++;

    my $interval = int( time / 10 );

    if ( defined $relay_last_interval{ $user } && $relay_last_interval{ $user } != $interval ) {
        delete $relay_interval_count{ $user };
    }

    $relay_last_interval{ $user } = $interval;
    $relay_interval_count{ $user }++;
    my $relay_ban = "";
    if ( $relay_ban ) {
        println() if ! $conn->{bg_relay};
        error( "you have been silenced for " . delta_time( time - ( $TH::data->{banned}->{$user}->{t} - time ) ) );
    } elsif ( $relay_duplicate_count{ $user } > 10 || $relay_interval_count{ $user } > 100 ) {
        relay_suppress( $conn, $msg );
    } elsif ( $msg =~ /\b$RELAY_OFFENSIVE_RE\b/i ) {
        relay_suppress( $conn, $msg );
    } elsif ( $msg =~ /\b$RELAY_PERSONAL_RE\b/i ) {
        relay_suppress( $conn, $msg, 1 );
    } else {
        print $::relaylog $msg."\n";

        foreach my $port ( keys %{ $TH::conns } ) {
            next if $port < 1;
            next if defined $skip && $port == $skip;

            my $c = $TH::conns->{$port};
            next if ! $c->{in_craps};
            next if defined $c->{do_relay_log};
            next if defined $user && $c->{udata}->{relay_ignore}->{$user};
            next if is_robot($c);   # robots don't get to listen

            my $ruser = $c->{user};
            my $bell;

            if ( $ruser ne '' && $ruser ne $conn->{user} ) {
                my @nicknames;

                if ( defined $c->{udata}->{nicknames} ) {
                    @nicknames = @{ $c->{udata}->{nicknames} };
                }

                foreach my $nickname ( $c->{user}, @nicknames ) {
                    if ( $msg =~ / .*\b\Q$nickname\E\b/i ) {
                        $bell = "\007";
                    }
                }
            }
                # Output an extra CRLF for Teletypes to avoid stacking output
                if ( $port != $TH::cur_fd && $TH::conns->{$port}->{tty} ){
                    output( $port, "\r\n", 1 );
                }
                output( $port, scr_line_clear($TH::conns->{$port}) . $bell . ' ' . $msg. "\n", 1 );
                readline_repaint( $TH::conns->{$port} );

        }
    }
    $TH::rotty_users = $rotty_tmp;
}

sub craps_nusers {
    my ( $msg ) = @_;
    my $sum = 0;
    foreach my $port ( keys %{ $TH::conns } ) {
        next if $port !~ /^\d+$/;
        next if $port == 0;
        my $c = $TH::conns->{$port};
        next if ! $c->{in_craps} && ! $c->{bg_relay};
        $sum++;
    }
    return $sum;
}
1;