package III::Controller::Users;

use strict;
use warnings;
use base 'Catalyst::Controller';
use Email::Valid;

=head1 NAME

III::Controller::Users - Catalyst Controller

=head1 DESCRIPTION

Catalyst Controller.

=head1 METHODS

=cut

=head2 index 

=cut

sub index : Private {

    my ( $self, $c ) = @_;

    my $role_id = $c->model('III::role')->search(
        {
            state => [qw/offline online/],
            level => { "<=", $c->user->obj->level },
        },
        { order_by => 'level DESC' }
    )->first->id;

    $c->response->redirect( $c->uri_for( $role_id, 'list' ) );
}

=item 

    Beschreibung : Aufbau des Menübaums zur Auswahl der Gruupen
    Rückgabe     : Teiltemplate der Gruppenauswahl

=cut

sub users : PathPart('users') Chained('/') CaptureArgs(1) {

    my ( $self, $c, $role_id ) = @_;

    # Für das Template
    $c->stash->{current_role_id} = $role_id;

    # Liste der Rollen nach Level
    $c->stash->{roles} = [
        $c->model('III::role')->search(
            {
                state => [qw/offline online/],
                level => { "<=", $c->user->obj->level },
            },

            { order_by => 'level DESC' }
          )->all
    ];
    $c->stash->{tree} = 'users/tree.tt2';

    # Den aktuellen Rolle direkt auslesen
    $c->stash->{role} = $c->model('III::role')->find($role_id);
}

=head2 list

Liste der Benutzer anzeigen

=cut

sub list : PathPart('list') Chained('users') {

    my ( $self, $c, $alpha ) = @_;

    my $role_id = $c->stash->{current_role_id};

    my $structuralunits = [ $c->user->obj->allstructuralunitsids ];

    my $user_count = $c->model('III::user')->search(

        {
            'me.state'                                       => [qw/offline online/],
            'role.role_id'                                   => $role_id,
            'function_has_structuralunits.structuralunit_id' => { -in => $structuralunits },
        },
        {
            order_by => 'me.lastname',
            join     => { 'functions' => [ 'role', 'function_has_structuralunits' ] },
        }
    )->count;

    if ( $user_count > 25 ) {

        my @alpha = $c->model('III::user')->search(
            {
                'me.state'                                       => [qw/offline online/],
                'role.role_id'                                   => $role_id,
                'function_has_structuralunits.structuralunit_id' => { -in => $structuralunits },

            },
            {
                join => { 'functions' => [ 'role', 'function_has_structuralunits' ] },

                +select  => [ \'SUBSTR(LTRIM(lastname),1,1) AS alpha' ],
                +as      => 'alpha',
                group_by => 'alpha',
                order_by => 'alpha',
            }
        )->all;

        $alpha ||= $alpha[0]->get_column('alpha');

        $c->stash->{alphas} = [ map { $_->get_column('alpha') } @alpha ];
        $c->stash->{current_alpha} = $alpha;

        # Liste der Benutzer, der dem Benutzer zugeteilten
        $c->stash->{list} = [
            $c->model('III::user')->search(

                {
                    'lastname'                                       => { like => $alpha . "%" },
                    'me.state'                                       => [qw/offline online/],
                    'role.role_id'                                   => $role_id,
                    'function_has_structuralunits.structuralunit_id' => { -in  => $structuralunits },
                },
                {
                    order_by => 'me.lastname',
                    join     => { 'functions' => [ 'role', 'function_has_structuralunits' ] },
                    prefetch => { 'functions' => [ 'role', { 'function_has_structuralunits' => 'structuralunit' } ] },
                }
              )->all
        ];

    } else {

        # Liste der Benutzer, der dem Benutzer zugeteilten
        $c->stash->{list} = [
            $c->model('III::user')->search(

                {
                    'me.state'                                       => [qw/offline online/],
                    'role.role_id'                                   => $role_id,
                    'function_has_structuralunits.structuralunit_id' => { -in => $structuralunits },
                },
                {
                    order_by => 'me.lastname',
                    join     => { 'functions' => [ 'role', 'function_has_structuralunits' ] },
                    prefetch => { 'functions' => [ 'role', { 'function_has_structuralunits' => 'structuralunit' } ] },
                }
              )->all
        ];

    }

    # Template auswählen
    $c->stash->{template} = 'users/list.tt2';
}

=head2 edit

    Beschreibung: Benutzer bearbeiten
    
=cut

sub edit : PathPart('edit') Chained('users') Args(1) {

    my ( $self, $c, $id ) = @_;
    $c->stash->{user}     = $c->model('III::user')->find($id);
    $c->stash->{template} = 'users/edit.tt2';
}

=head2 view

    Beschreibung: Benutzer anschauen
    
=cut

sub view : PathPart('view') Chained('users') Args(1) {

    my ( $self, $c, $id ) = @_;

    my $role_id = $c->stash->{current_role_id};

    my $structuralunits = [ $c->user->obj->allstructuralunitsids ];

    my $user = $c->model('III::user')->search(
        {
            'me.user_id'                                     => $id,
            'role.role_id'                                   => $role_id,
            'function_has_structuralunits.structuralunit_id' => { -in => $structuralunits }
        },
        { join => { functions => [ 'role', 'function_has_structuralunits' ] } }

    )->first;

    if ($user) {

        $c->stash->{user}     = $c->model('III::user')->find($id);
        $c->stash->{template} = 'users/view.tt2';

    } else {

        $c->forward('/failed');

    }
}

=head2 create

    Beschreibung : Einen neuen Benutzer anlegen
    Rückgabe     : Formular für das neuanlegen

=cut

sub create : PathPart('create') Chained('users') {

    my ( $self, $c ) = @_;

    if ( $c->flash->{noclean} ) {

        # Funktionen für die Anzeige aufbereiten
        foreach my $role_id ( keys %{ $c->session->{functions} } ) {

            my $structuralunits_ids = $c->session->{functions}{$role_id};
            my $structuralunits     = $c->model('III::structuralunit')->search( { structuralunit_id => { -in => $structuralunits_ids } } );
            my $role                = $c->model('III::role')->find($role_id);

            if ( $role && $structuralunits->count ) {
                push @{ $c->stash->{selected_functions} }, { role => $role->name, id => $role->id, structuralunits => [ $structuralunits->get_column('name')->all ] };
            }
        }

    } else {

        # Funktion zurücksetzen
        delete $c->session->{functions};
    }

    $c->stash->{template} = 'users/create.tt2';
}

=head2 docreate

Übergebene Daten speichern

=cut

sub docreate : PathPart('docreate') Chained('users') Args(0) {

    my ( $self, $c ) = @_;

    my $role = $c->stash->{role};

    # Retrieve the values from the form
    my $username  = $c->request->params->{username};
    my $firstname = $c->request->params->{firstname};
    my $lastname  = $c->request->params->{lastname};
    my $email     = $c->request->params->{email};
    my $idmdv     = $c->request->params->{idmdv};
    my $state     = $c->request->params->{state};

    # Eingabe-Datenvalidierung
    my $emailvalid = Email::Valid->address($email);
    my $userexist = $c->model('III::user')->search( { username => $username } )->count;

    $c->flash->{error}{firstname} = "Bitte geben Sie einen Nachnamen an"                               if ( !$lastname );
    $c->flash->{error}{firstname} = "Bitte geben Sie einen Vornamen an"                                if ( !$firstname );
    $c->flash->{error}{username}  = "Bitte geben Sie einen Benutzernamen an"                           if ( !$username );
    $c->flash->{error}{email}     = "Bitte geben Sie einen E-Mailadresse an"                           if ( !$email );
    $c->flash->{error}{email}     = 'Bitte geben Sie die E-Mailadresse im Format user@domain.tld an'   if ( !$emailvalid );
    $c->flash->{error}{username}  = 'Benutzername ist schon vergeben'                                  if ($userexist);
    $c->flash->{error}{username}  = "Bitte geben Sie ein mindestens 5 Zeichen langen Benutzernamen an" if ( length($username) > 0 && length($username) < 5 );
    $c->flash->{error}{username}  = "Bitte geben Sie ein maximal 35 Zeichen langen Benutzernamen an"   if ( length($username) > 0 && length($username) > 35 );
    $c->flash->{error}{functions} = "Bitte ordnen Sie mindestens eine Funktion zu."                    if ( keys %{ $c->session->{functions} } == 0 );

    if ( keys %{ $c->flash->{error} } == 0 ) {

        # Benutzer anlegen
        my $user = $c->model('III::user')->create(
            {
                username  => $username,
                firstname => $firstname,
                lastname  => $lastname,
                email     => $email,
                idmdv     => $idmdv,
                state     => ( $state ? 'online' : 'offline' ),
            }
        );

        # zufälliges Password erzeugen
        my $password = $user->setrandompassword;
        $user->update;

        $c->stash->{admin}    = $c->user->obj;
        $c->stash->{user}     = $user;
        $c->stash->{password} = $password;

        # Funktionen zuordnen
        foreach my $role_id ( keys %{ $c->session->{functions} } ) {

            my $structuralunits_ids = $c->session->{functions}{$role_id};
            my $structuralunits = $c->model('III::structuralunit')->search( { structuralunit_id => { -in => $structuralunits_ids } } );
            $role = $c->model('III::role')->find($role_id);

            if ( $role && $structuralunits->count ) {

                my $function = $user->add_to_functions( { role_id => $role->id } );

                foreach my $structuralunit ( $structuralunits->all ) {

                    $function->add_to_function_has_structuralunits( { structuralunit_id => $structuralunit->id } );
                }
            }

        }

        # Liste der anzulegenden Funktion löschen
        delete $c->session->{functions};

        $c->email(
            header => [
                From    => $c->user->mailaddress,
                To      => $user->mailaddress,
                Subject => 'Zugangsdaten ESRA3',
            ],
            template => 'users/welcome_mail.tt2',
        );

        # Weiterleitungen zur Übersichtsliste
        $c->response->redirect( $c->uri_for( '/users', $role->id, 'list' ) );

    } else {

        $c->flash->{error_msg} = "Bitte füllen Sie die markierten Felder korrekt aus";

        # Werte sichern
        foreach my $field (qw/username firstname lastname  idmdv state/) {
            $c->flash->{$field} = $c->request->params->{$field};
        }

        $c->flash->{email} = $emailvalid || $email;
        $c->flash->{noclean} = 1;

        # Zurück
        $c->response->redirect( $c->request->referer );
    }
}

=head2 update 

    Beschreibung : Benutzerdaten speichern
    Parameter    : die 
    Rückgabe     : Je nach auswahl zurück zur Maske oder zur Liste weiterleiten

=cut

sub update : PathPart('update') Chained('users') Args(1) {

    my ( $self, $c, $user_id ) = @_;

    # Rolle aus dem Stash
    my $role = $c->stash->{role};

    # Aktuellen Benutzer auslesen
    my $user = $c->model('III::user')->find($user_id);

    # Felder updaten
    foreach my $field (qw/username firstname lastname email idmdv/) {

        $user->$field( $c->request->params->{$field} );
    }

    # Password-Verwaltung - Kennwort als MD5 ablegen
    my $password = $c->request->param('password');
    $user->setpassword($password);

    # Sonderbehandlung / Status-Feld
    my $state = $c->request->params->{state};

    if ($state) {

        $user->state('online');

    } elsif ( !$state && $user->state eq 'online' ) {

        $user->state('offline');
    }

    # Nur wenn Änderungen vorhanden sind
    if ( $user->is_changed ) {

        $c->flash->{status_msg} = "Änderungen wurden gespeichert";

        # Update ausführen
        $user->update;

    } else {

        # Es wurde nichts geändert
        $c->flash->{status_msg} = "Es wurden keine Änderungen vorgenommen";
    }

    # Weiterleitung je nach Auswahl
    if ( $c->req->params->{saveandback} ) {

        $c->response->redirect( $c->uri_for( '/users', $role->id, 'list' ) );

    } else {

        $c->response->redirect( $c->request->referer );

    }
}

=head2 delete 

Einen Benutzer löschen

=cut

sub delete : PathPart('delete') Chained('users') Args(1) {

    my ( $self, $c, $user_id ) = @_;

    # Rolle aus dem Stash
    my $role = $c->stash->{role};

    # TODO rechte prüfen

    # Benutzer suchen
    my $user = $c->model('III::user')->find($user_id);

    # Wenn ein benutzer gefunden wurde
    if ($user) {
        $user->state('deleted');
        $user->update;
    }

    # Use 'flash' to save information across requests util it's read
    $c->flash->{status_msg} = "Benutzer " . $user->name . " gelöscht";

    # Redirect the user back to the list page with status msg as an arg
    $c->response->redirect( $c->uri_for( '/users', $role->id, 'list' ) );
}

=head1 AUTHOR

Jens Gassmann <gassmann@angel.de>

=head1 LICENSE


=cut

1;