from os import listdir, mkdir
from os.path import basename, isdir
from shutil import rmtree, copyfile
from threading import Thread
from xml.dom.minidom import parse

from Main.models import *
from .main import solution_path


def start_new(host):
    in_queue = list(Solution.objects.filter(result='IN QUEUE'))
    if in_queue:
        sol = in_queue[0]
        for s in in_queue:
            dif = s.task.block.priority * 10 + s.task.priority - sol.task.block.priority * 10 - sol.task.priority
            if dif > 0:
                sol = s
            elif dif == 0 and s.id < sol.id:
                sol = s
        Tester(sol, host).test()


def is_project(path):
    return any([x.endswith('.csproj') for x in listdir(path)])


def get_node_value(element):
    return element[0].firstChild.nodeValue


def nunit_path(working_dir):
    return '..{}'.format(sep) * len(working_dir.split(sep)) + 'nunit_console{}nunit3-console.exe'.format(sep)


class Tester:

    def __init__(self, solution, host):
        self.solution = solution
        self.host = host
        self.working_dir = ''
        self.files = []

    # функция компиляции
    def build(self, path):
        # решение для UNIX
        # shell('msbuild ' + path + ' /p:Configuration=Debug')

        # решение для Windows
        cmd = 'dotnet build {} -o {}\\bin\\Debug'.format(path, path)
        with self.solution.log_fs as fs:
            shell(cmd, fs)

    def build_and_copy(self, path, working_dir):
        if exists(join(path, 'bin', 'Debug')):
            rmtree(join(path, 'bin', 'Debug'))
        self.build(path)
        name = basename(path)
        if not exists(join(path, 'bin', 'Debug')) or not any(
                x.endswith('.exe') for x in listdir(join(path, 'bin', 'Debug'))):
            return False
        self.files.append(basename(path))
        for file in listdir(join(path, 'bin', 'Debug')):
            if exists(join(path, 'bin', 'Debug', file)):
                new_file = join(working_dir, basename(file))
                try:
                    copyfile(join(path, 'bin', 'Debug', file), new_file)
                except:
                    pass
            else:
                return False
        return True

    def push(self):
        solution = self.solution
        if solution.result == 'SOLUTION ERROR':
            return
        solution.result = 'IN QUEUE'
        solution.save()
        from Main.models import System
        if len(Solution.objects.filter(result='TESTING')) < int(System.objects.get(key='queue_size').value):
            self.test()

    def delete_everything(self):
        ssp = solution_path(self.solution.path())
        sln_path = join(ssp, '.idea')
        if exists(sln_path):
            rmtree(sln_path)
        sln_path = join(ssp, '.vs')
        if exists(sln_path):
            rmtree(sln_path)
        sln_path = ssp
        for p in listdir(sln_path):
            if isdir(join(sln_path, p)):
                if exists(join(sln_path, p, 'bin')):
                    rmtree(join(sln_path, p, 'bin'))
                if exists(join(sln_path, p, 'obj')):
                    rmtree(join(sln_path, p, 'obj'))
        if exists(self.working_dir):
            rmtree(self.working_dir)
        if exists(join(self.solution.path(), 'solution.zip')):
            remove(join(self.solution.path(), 'solution.zip'))
        if exists(join(self.solution.path(), '__MACOSX')):
            rmtree(join(self.solution.path(), '__MACOSX'))
        if exists(join(sln_path, '.DS_Store')):
            remove(join(sln_path, '.DS_Store'))
        if exists(join(sln_path, 'test_folder')):
            rmtree(join(sln_path, 'test_folder'))

    def nunit_testing(self):
        solution = self.solution
        with self.solution.log_fs as fs:
            fs.write(b'Building image\n')
        shell('docker build -t solution_{} {}'.format(self.solution.id, self.working_dir))
        with self.solution.log_fs as fs:
            fs.write(b'Image built successfully\n')

        def execute():
            with self.solution.log_fs as fs:
                shell('docker run --name solution_container_{} solution_{}'.format(self.solution.id, self.solution.id),
                      output=fs)

        solution.write_log('Running container')
        t = Thread(target=execute)
        t.start()
        t.join(self.solution.task.time_limit / 1000)
        solution.write_log('Running finished')
        with self.solution.log_fs as fs:
            shell('docker cp solution_container_{}:/app/TestResults.xml {}'.format(self.solution.id, self.working_dir),
                  fs)
        with self.solution.log_fs as fs:
            shell('docker rm --force solution_container_{}'.format(self.solution.id), fs)
        with self.solution.log_fs as fs:
            shell('docker image rm solution_{}'.format(self.solution.id), fs)
        if not exists(join(self.working_dir, 'TestResults.xml')):
            self.solution.set_result('Time limit')
            solution.write_log('Result file not found in container')
            return
        solution.write_log('Result file found in container')
        try:
            doc = parse(join(self.working_dir, 'TestResults.xml'))
            res = get_node_value(doc.getElementsByTagName('Passed')) + '/' + get_node_value(
                doc.getElementsByTagName('Total'))
            self.solution.details = ''
            for el in doc.getElementsByTagName('Result'):
                self.solution.details += '<h5><b>' + get_node_value(el.getElementsByTagName('MethodName')) + '</b></h5>'
                r = get_node_value(el.getElementsByTagName('Successful'))
                if r == 'true':
                    self.solution.details += '<div style="color: green;">Passed</div>'
                else:
                    self.solution.details += '<div style="color: red;">Failed</div>'
                    mes = get_node_value(el.getElementsByTagName('Message'))
                    self.solution.details += '<pre>{}</pre>'.format(mes)
        except:
            solution.write_log('Unknown error')
            res = 'TEST ERROR'
        self.solution.set_result(res)

    def test(self):
        solution = self.solution
        solution.result = 'TESTING'
        solution.save()
        try:
            if not exists(self.solution.task.tests_path()):
                with self.solution.log_fs as fs:
                    fs.write(b'No test file found\n')
                solution.set_result('TEST ERROR')
                solution.save()
                self.delete_everything()
                start_new(self.host)
                return
            sln_path = solution_path(join(MEDIA_ROOT, 'solutions', str(solution.id)))
            if sln_path == '':
                solution.set_result('TEST ERROR')
                solution.save()
                self.delete_everything()
                start_new(self.host)
                return
            working_dir = join(sln_path, 'test_folder')
            if exists(working_dir):
                try:
                    rmtree(working_dir)
                except:
                    remove(working_dir)
            mkdir(working_dir)
            with self.solution.log_fs as fs:
                fs.write(b'Testing directory created\n')
            for project in listdir(sln_path):
                solution.write_log('Checking if {} is project'.format(project))
                prj = project
                project = join(sln_path, project)
                if isdir(project) and is_project(project) and basename(project) != 'TestsProject':
                    if not self.build_and_copy(project, working_dir):
                        solution.set_result('Compilation error')
                        solution.write_log('Failed to compile project {}'.format(prj))
                        solution.save()
                        self.delete_everything()
                        start_new(self.host)
                        return
            dll_path = solution.task.tests_path()
            solution.write_log('Copying test file to working directory')
            copyfile(dll_path, join(working_dir, str(solution.task.id) + '.cs'))
            solution.write_log('Test file copied')
            for file in listdir('SprintTest'):
                try:
                    copyfile(join('SprintTest', file), join(working_dir, file))
                except:
                    pass
            self.working_dir = working_dir
            build_tests_cmd = 'csc -out:{} -t:library /r:{} /r:{} /r:{} '.format(join(self.working_dir, 'tests.dll'),
                                                                                 join(self.working_dir,
                                                                                      'SprintTest.dll'),
                                                                                 join(working_dir,
                                                                                      'System.Runtime.dll'),
                                                                                 join(working_dir,
                                                                                      'System.Reflection.dll'))
            for file in self.files:
                build_tests_cmd += '/r:{}.dll '.format(join(self.working_dir, file))
            build_tests_cmd += self.solution.task.tests_path()
            if exists(join(self.working_dir, 'tests.dll')):
                remove(join(self.working_dir, 'tests.dll'))
            solution.write_log('Building tests file started')
            with self.solution.log_fs as fs:
                shell(build_tests_cmd, fs)
            with self.solution.log_fs as fs:
                fs.write(b'Building tests file finished\n')
            if exists(join(self.working_dir, 'tests.dll')):
                with self.solution.log_fs as fs:
                    fs.write(b'Got .dll tests file\n')
                for file in ExtraFile.objects.filter(task=self.solution.task):
                    copyfile(file.path, join(working_dir, file.filename))
                self.nunit_testing()
            else:
                solution.set_result('TEST ERROR')
                solution.write_log('Failed to compile tests')
        except:
            solution.set_result('TEST ERROR')
            raise
            with self.solution.log_fs as fs:
                fs.write(b'Unknown error\n')
        solution.save()
        self.delete_everything()
        start_new(self.host)