import random

import numpy as np

from methods.dp_method import compute_overavg_ranks, compute_slow_ranks, compute_fast_ranks
from methods.methods_proto import TaskSequencing


def compute_upward_rank_iterative(workflow):
    tasks_without_successors = [task for task in workflow.tasks if not task.successors]
    rank_up = {task: workflow.task_avg_worktime[task] for task in tasks_without_successors}

    for task in workflow.sorted_tasks[::-1]:
        if task in rank_up:
            continue
        max_rank = 0
        for successor in task.successors:
            trans_time = workflow.task_avg_transtime[task][successor]
            rank = rank_up[successor] + trans_time
            max_rank = max(max_rank, rank)
        rank_up[task] = max_rank + workflow.task_avg_worktime[task]
    return rank_up


def compute_downward_rank_iterative(workflow):
    tasks_without_predecessors = [task for task in workflow.tasks if not task.predecessors]
    rank_down = {task: 0 for task in tasks_without_predecessors}

    for task in workflow.sorted_tasks:
        if task in rank_down:
            continue
        max_rank = 0
        for predecessor in task.predecessors:
            trans_time = workflow.task_avg_transtime[predecessor][task]
            work_time = workflow.task_avg_worktime[predecessor]
            rank = rank_down[predecessor] + trans_time + work_time
            max_rank = max(max_rank, rank)
        rank_down[task] = max_rank
    return rank_down


class UpwardRankTaskSequencing(TaskSequencing):
    def run(self, workflow, system):
        rank_up = compute_upward_rank_iterative(workflow)
        return sorted(workflow.tasks, key=lambda x: rank_up[x], reverse=True)


class DownwardRankTaskSequencing(TaskSequencing):
    def run(self, workflow, system):
        rank_down = compute_downward_rank_iterative(workflow)
        return sorted(workflow.tasks, key=lambda x: rank_down[x])


class DPRankTaskSequencing(TaskSequencing):
    def run(self, workflow, system):
        return sorted(workflow.tasks, key=lambda x: x['rank_dp'], reverse=True)


class MixedRandomTaskSequencing(TaskSequencing):
    def __init__(self):
        self.chosen = random.randint(0, 2)
        self.method = [UpwardRankTaskSequencing, DownwardRankTaskSequencing, UpwardRankTaskSequencing][self.chosen]()

    def run(self, workflow, system):
        return workflow.sorted_tasks


class CompositeTaskSequencing(TaskSequencing):
    def __init__(self, TS):
        self.TS = TS
        self.impl = [UpwardRankTaskSequencing, DownwardRankTaskSequencing, DPRankTaskSequencing][self.TS]()

    def run(self, workflow, system):
        # return workflow.sorted_tasks
        # return self.impl.run(workflow, system)
        return workflow.sorted_tasks


class FastRankBasedTaskSequencing(TaskSequencing):
    def run(self, workflow, system):
        if not hasattr(workflow.tasks[0], 'fast_rank'):
            ranks = compute_fast_ranks(workflow)
            return sorted(workflow.tasks, key=lambda x: ranks[x], reverse=True)
        else:
            return sorted(workflow.tasks, key=lambda x: x.fast_rank, reverse=True)


class SlowRankBasedTaskSequencing(TaskSequencing):
    def run(self, workflow, system):
        if not hasattr(workflow.tasks[0], 'slow_rank'):
            ranks = compute_slow_ranks(workflow)
            return sorted(workflow.tasks, key=lambda x: ranks[x], reverse=True)
        else:
            return sorted(workflow.tasks, key=lambda x: x.slow_rank, reverse=True)


class OveravgRankBasedTaskSequencing(TaskSequencing):
    def run(self, workflow, system):
        if not hasattr(workflow.tasks[0], 'overavg_rank'):
            ranks = compute_overavg_ranks(workflow)
            return sorted(workflow.tasks, key=lambda x: ranks[x], reverse=True)
        else:
            return sorted(workflow.tasks, key=lambda x: x.overavg_rank, reverse=True)


class FrequencyAwareTaskSequencing(TaskSequencing):
    def __init__(self, TS):
        self.TS = TS
        self.impl = [FastRankBasedTaskSequencing, SlowRankBasedTaskSequencing, OveravgRankBasedTaskSequencing][
            self.TS]()

    def run(self, workflow, system):
        # return self.impl.run(workflow, system)
        return workflow.sorted_tasks