#!/usr/bin/perl -w
#
# Interface To Java, XML files
#
#### IMPORTS ##################################################################

use strict;

{
package TestFileHandler;

use strict;
use warnings;

use Data::Dumper;
use XML::Simple;

#### INITIALIZATION ############################################################

#### SUB DEFINITIONS ###########################################################

sub getTestsFromJavaFiles {
    my ($class, $docroot) = @_;

    my $directory = "$docroot/tests";
    opendir (DIR, $directory);
    my @classes;
    while (my $file = readdir(DIR))
    {
        my $path="$docroot/tests/".$file;
        my @shit=split(/\./, $file);
        if (($file ne ".") && ($file ne ".."))
        {
        push @classes, $path;
        }
    }

    closedir(DIR);

    my @tests;
    foreach my $file(@classes)
    {
        my $test = {};
        open(my $fh, '<:encoding(UTF-8)', $file);
        my @filename = split('/', $file);
        my $lastsplitidx = @filename - 1;

        my @filenameWithoutExtension = split('\.', $filename[$lastsplitidx]);
        $test->{'name'} = $filenameWithoutExtension[0];
        #warn $test->{'name'};
        my @testMethods = ();
        while (my $row = <$fh>)
        {
          chomp $row;
          if ($row=~ /public void (test[0-9A-z]+)\s*\(([0-9A-z, ]+)?\)/)
          {
                my $testMethod = {};
                $testMethod->{'name'} = $1;
                my @parameters = ();
                if ($2)
                {
                    my @params=split(/,\s*/, $2);
                    foreach my $para (@params)
                    {
                        my ($type, $parameter) = split(/\s+/, $para);
                        push ( @parameters, $parameter);
                    }
                }
                $testMethod->{'parameters'} = \@parameters;
                push(@testMethods, $testMethod);
          }
        }
        $test->{'testMethods'} = \@testMethods;
        push (@tests, $test);
    }

    #warn Data::Dumper::Dumper(\@tests);

    return \@tests;

}

sub inputDataFromXMLs {

    my ($class, $docroot, $tests) = @_;

    my @users = ();
    my $expectedResults = {};

    my $directory = "$docroot/xmls";
    opendir (DIR, $directory);
    my @xmls;
    while (my $file = readdir(DIR))
    {
        my $path="$docroot/xmls/".$file;
        my @shit=split(/\./, $file);
        if (($file ne "testng.xml") && ($file ne ".") && ($file ne ".."))
        {
        push @xmls, $path;
        }
    }
    closedir(DIR);

    foreach my $file(@xmls)
    {
        my $configg = XMLin($file, KeyAttr => {test => 'name', parameter => 'name'}, ForceArray => {'parameter'});


        my ($as, $namesplit) = split('_', $configg -> {name});
        my $name = $namesplit;
        my $email = $configg -> {parameter} -> {email} -> {value};
        my $pass = $configg -> {parameter} -> {password} -> {value};

        my $user={
         'name' => $name,
         'emails' => $email,
         'password' => $pass,
        };

        push @users, $user;

        foreach my $test (@{$tests})
            {

                foreach my $testMethod (@{$test->{'testMethods'}})
                {
                    my $run = $configg -> {test} -> {"$testMethod->{'name'}"};
                    if($run)
                    {
                        $expectedResults->{$test->{'name'}}->{'run'}->{$user->{'name'}} = 1;

                        my $tf = $configg -> {test} -> {"$testMethod->{'name'}"} -> {parameter} -> {shouldSucceed} -> {value};
                        my $in;

                        if($tf eq 'true'){
                            $in = 1;
                        }else{
                            $in = 0;
                        }
                        $expectedResults->{$test->{'name'}}->{$testMethod->{'name'}}->{'shouldSucceed'}->{$user->{'name'}} = $in;#(defined($paramValue) && $paramValue eq 'on') ? 1 : 0;

                        foreach my $parameter (@{$testMethod->{'parameters'}})
                        {
                            my $tf = $configg -> {test} -> {"$testMethod->{'name'}"} -> {parameter} -> {$parameter} -> {value};
                            my $in;

                            if($tf eq 'true'){
                                $in = 1;
                            }else{
                                $in=0;
                            }
                            $expectedResults->{$test->{'name'}}->{$testMethod->{'name'}}->{$parameter}->{$user->{'name'}} = $in;#(defined($paramValue) && $paramValue eq 'on') ? 1 : 0;
                        }
                    }
                }
            }

            warn Dumper($configg);
    }

    return (\@users, $expectedResults);
}

sub generateXMLs
{
    my ($class, $docroot, $host, $tests, $users, $expectedResults) = @_;

    foreach my $user (@{$users})
    {
        my $filename = "$docroot/xmls/example.".$user->{'name'}.".xml";
        open(my $fh, '>', $filename);
        chmod 0777, $fh;


        my $xmlContent = {};
        my @xmlTests = ();

        my @loginParameters = ();
        my $loginParameter = {
            'name' => "logintype",
            'value' => "custom"
        };
        my $emailParameter = {
            'name' => "email",
            'value' => $user->{'emails'}
        };
        my $passParameter = {
            'name' => "password",
            'value' => $user->{'password'}
        };
        push(@loginParameters, $loginParameter);
        push(@loginParameters, $emailParameter);
        push(@loginParameters, $passParameter);
        $xmlContent->{'parameter'} = \@loginParameters;


        foreach my $test (@{$tests})
        {
            my $run = $expectedResults->{$test->{'name'}}->{'run'}->{$user->{'name'}};

            if($run == 1)
            {

            my $xmlTest = {};
            my @xmlParameters;
            foreach my $testMethod (@{$test->{'testMethods'}})
            {
                $xmlTest->{'name'} = $testMethod->{'name'};
                #begin classes
                my $classname = "com.cae.learningspace.acceptancetests.suites.".$test->{'name'};
                my @classes = ();
                my $class = {};
                $class->{'name'} = $classname;
                push @classes, $class;
                my $classrow->{'class'} = \@classes;
                $xmlTest->{'classes'} = $classrow;
                #end classes
                foreach my $parameter (@{$testMethod->{'parameters'}})
                {
                    my $condition = $expectedResults->{$test->{'name'}}->{$testMethod->{'name'}}->{$parameter}->{$user->{'name'}};
                    my $value;
                    if ($condition == 1)
                    {
                        $value = 'true';
                    }
                    else
                    {
                        $value = 'false';
                    }
                    my $xmlParameter = {
                        'name' => $parameter,
                        'value' => $value
                    };
                    push(@xmlParameters, $xmlParameter);
                }

                my $condition = $expectedResults->{$test->{'name'}}->{$testMethod->{'name'}}->{'shouldSucceed'}->{$user->{'name'}};
                my $value;
                if ($condition == 1)
                {
                    $value = 'true';
                }
                else
                {
                    $value = 'false';
                }
                my $shouldParameter = {
                    'name' => 'shouldSucceed',
                    'value' => $value
                };
                push(@xmlParameters, $shouldParameter);
            }
            $xmlTest->{'parameter'} = \@xmlParameters;
            push(@xmlTests, $xmlTest)

            }
        }
        $xmlContent->{'name'} = "as_".$user->{'name'};
        $xmlContent->{'test'} = \@xmlTests;
        $xmlContent->{'configfailurepolicy'} = "continue";

        warn XMLout($xmlContent, RootName => "suite");
        print $fh XMLout($xmlContent, RootName => "suite" );
        close($fh);
    }

    #begin testng.xml generate
    my $testngfilename = "$docroot/xmls/testng.xml";
    open (my $testngFile, '>', $testngfilename);
    chmod 0777, $testngFile;

    my $testngContent = {};
    my @suitesParameters = ();

    my $browserParameter = {
        'name' => "browser",
        'value' => "firefox"
    };
    my $websiteParameter = {
        'name' => "website",
        'value' => ($host) ? $host : "http://ls-test"
    };
    push (@suitesParameters, $browserParameter);
    push (@suitesParameters, $websiteParameter);

    my $directory = "$docroot/xmls/";
    opendir (DIR, $directory);
    my @suiteFiles = ();
    while (my $file = readdir(DIR))
    {
        if (($file ne "testng.xml") && ($file ne ".") && ($file ne ".."))
        {
            my $suiteFile->{'path'} = $file;
            push (@suiteFiles, $suiteFile);
        }
    }
    my $suiteRow->{'suite-file'} = \@suiteFiles;

    $testngContent->{'suite-files'} = $suiteRow;
    $testngContent->{'parameter'} = \@suitesParameters;
    $testngContent->{'name'} = "allSuites";
    $testngContent->{'configfailurepolicy'} = "continue";
    print $testngFile XMLout($testngContent, RootName => "suite");

    close $testngFile;
    #end testng.xml generate

}



###### NAMESPACE ##############################################################

}


###### SUCCESS ################################################################

1;