package BeastBB::Controller::Install;

use 5.30.3;

use strict;
use warnings;

use Mojo::Base 'Mojolicious::Controller';
use Mojo::URL;

use Params::ValidationCompiler 'validation_for';
use Types::Standard qw/Str HashRef/;

use BeastBB::Database;
use BeastBB::ConfigWriter;
use BeastBB::DAO::UserManager;
use BeastBB::Constants ('ConfigFile');

sub welcome {
    my $self  = shift;
    my $error = $self->param('error');
    $self->stash( error  => $error );
    $self->stash( config => $self->config );
    $self->render;
}

sub install_database {
    my $self = shift;

    if ( exists $self->config->{db} ) {
        $self->code(404);
        $self->render( text => 'This endpoint no longer has sense.' );
    }

    my $config_db;
    my $user     = $self->param('username');
    my $password = $self->param('password');
    my $host     = $self->param('host');
    my $port     = $self->param('port');
    my $dbname   = $self->param('dbname');

    $user     = undef if ( length $user ) == 0;
    $password = undef if ( length $password ) == 0;
    $host     = undef if ( length $host ) == 0;
    $port     = undef if ( length $port ) == 0;
    $dbname   = undef if ( length $dbname ) == 0;

    $config_db = {
        ( defined $user )     ? ( user     => $user )     : (),
        ( defined $password ) ? ( password => $password ) : (),
        ( defined $host )     ? ( host     => $host )     : (),
        ( defined $port )     ? ( port     => $port )     : (),
        ( defined $dbname )   ? ( dbname   => $dbname )   : (),
    };

    eval { $self->TestNewDatabaseConfig( config => $config_db ); };

    if ($@) {
        STDERR->say($@);
        my $error_url = Mojo::URL->new('/')->query( error => $@ );
        $self->redirect_to($error_url);
    }

    $self->config->{db} = $config_db;
    local $Data::Dumper::Terse = 1;
    my $config_writer =
      BeastBB::ConfigWriter->new( config_file => ConfigFile() );
    $config_writer->WriteToConfigFile(
        content => Data::Dumper::Dumper $self->config );
    $self->redirect_to('/');
}

sub admin_user_create {
    my $self            = shift;
    my $username        = $self->param('username');
    my $matrix_address  = $self->param('matrix_address');
    my $password        = $self->param('password');
    my $repeat_password = $self->param('repeat_password');
    my $config          = $self->config;

    return unless $self->CheckDefinedParametersAdminCreation(
        username        => $username,
        matrix_address  => $matrix_address,
        password        => $password,
        repeat_password => $repeat_password
    );
    my $user_manager         = BeastBB::DAO::UserManager->new( app => $self );
    my $response_create_user = $user_manager->Create(
        username        => $username,
        matrix_address  => $matrix_address,
        password        => $password,
        repeat_password => $repeat_password,
        is_confirmed    => 1,
        groupname       => 'admin',
    );
    if ( $response_create_user->IsError ) {
        my $error_url = Mojo::URL->new('/')
          ->query( error => $response_create_user->ErrorMessage );
        $self->redirect_to($error_url);
    }

    my $config_writer =
      BeastBB::ConfigWriter->new( config_file => ConfigFile );
    $config->{finished_install} = 1;
    local $Data::Dumper::Terse = 1;
    $config_writer->WriteToConfigFile(
        content => Data::Dumper::Dumper $self->config );
    $self->redirect_to('/');
}

{
    my $validator = validation_for(
        params => {
            username        => { type => Str },
            matrix_address  => { type => Str },
            password        => { type => Str },
            repeat_password => { type => Str },
        },
    );

    sub CheckDefinedParametersAdminCreation {
        my $self   = shift;
        my %params = $validator->(@_);
        my ( $username, $matrix_address, $password, $repeat_password ) =
          @params{
            'username', 'matrix_address', 'password',
            'repeat_password'
          };
        print Data::Dumper::Dumper \%params;
        if (
            !$self->AreAllParametersAreDefined(
                $username, $matrix_address, $password, $repeat_password
            ) || !$username || !$matrix_address || !$password || !$repeat_password
          )
        {
            my $error_url = Mojo::URL->new('/')
              ->query( error => 'Not all required arguments were passed.' );
            $self->redirect_to($error_url);
            return 0;
        }
        return 1;
    }
}

sub AreAllParametersAreDefined {
    my $self = shift;
    for my $param (@_) {
        return 0 if !defined $param;
    }
    return 1;
}

{
    my $validator =
      validation_for( params => { config => { type => HashRef } } );

    sub TestNewDatabaseConfig {
        my $self     = shift;
        my %params   = $validator->(@_);
        my $config   = $params{config};
        my $database = BeastBB::Database->NewFromConfig( config => $config );
        my $succesful_query_result_array =
          $database->DB->query('SELECT 1')->array;
        if (
            !(
                exists $succesful_query_result_array->[0]
                && $succesful_query_result_array->[0] == 1
            )
          )
        {
            die "Unable to retrieve data from the database.";
        }

    }
}
1;