# 用于提供对外接口
from base_optimizer.optimizer_scanbased import *
from base_optimizer.optimizer_celldivision import *
from base_optimizer.optimizer_hybridgenetic import *
from base_optimizer.optimizer_feederpriority import *
from base_optimizer.optimizer_aggregation import *
from base_optimizer.optimizer_twophase import *
from base_optimizer.optimizer_mathmodel import *

from base_optimizer.result_analysis import *


def base_optimizer(machine_index, pcb_data, component_data, feeder_data=None, method='', hinter=False):

    if method == 'cell_division':  # 基于元胞分裂的遗传算法
        component_result, cycle_result, feeder_slot_result = optimizer_celldivision(pcb_data, component_data,
                                                                                    hinter=False)
        placement_result, head_sequence = greedy_placement_route_generation(component_data, pcb_data, component_result,
                                                                            cycle_result, feeder_slot_result)
    elif method == 'feeder_scan':  # 基于基座扫描的供料器优先算法
        # 第1步：分配供料器位置
        nozzle_pattern = feeder_allocate(component_data, pcb_data, feeder_data, figure=False)
        # 第2步：扫描供料器基座，确定元件拾取的先后顺序
        component_result, cycle_result, feeder_slot_result = feeder_base_scan(component_data, pcb_data, feeder_data,
                                                                              nozzle_pattern)

        # 第3步：贴装路径规划
        placement_result, head_sequence = greedy_placement_route_generation(component_data, pcb_data, component_result,
                                                                            cycle_result, feeder_slot_result)
        # placement_result, head_sequence = beam_search_for_route_generation(component_data, pcb_data, component_result,
        #                                                                    cycle_result, feeder_slot_result)

    elif method == 'hybrid_genetic':  # 基于拾取组的混合遗传算法
        component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_hybrid_genetic(
            pcb_data, component_data, hinter=False)

    elif method == 'aggregation':  # 基于batch-level的整数规划 + 启发式算法
        component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_aggregation(
            component_data, pcb_data)
    elif method == 'genetic_scanning':
        component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_genetic_scanning(
            component_data, pcb_data, hinter=False)
    elif method == 'mip_model':
        component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_mathmodel(
            component_data, pcb_data, hinter=True)
    elif method == "two_phase":
        component_result, feeder_slot_result, cycle_result = gurobi_optimizer(pcb_data, component_data, feeder_data,
                                                                              initial=True, partition=True,
                                                                              reduction=True, hinter=hinter)

        placement_result, head_sequence = scan_based_placement_route_generation(component_data, pcb_data,
                                                                                component_result, cycle_result)
    else:
        raise 'method is not existed'

    info = OptInfo()
    assigned_nozzle = ['' if idx == -1 else component_data.loc[idx]['nz'] for idx in component_result[0]]
    info.cycle_counter = sum(cycle_result)

    for cycle in range(len(cycle_result)):
        pick_slot = set()
        for head in range(max_head_index):
            idx = component_result[cycle][head]
            if idx == -1:
                continue

            nozzle = component_data.loc[idx]['nz']
            if nozzle != assigned_nozzle[head]:
                if assigned_nozzle[head] != '':
                    info.nozzle_change_counter += 1
                assigned_nozzle[head] = nozzle

            pick_slot.add(feeder_slot_result[cycle][head] - head * interval_ratio)
        info.pickup_counter += len(pick_slot) * cycle_result[cycle]

        pick_slot = list(pick_slot)
        pick_slot.sort()
        for idx in range(len(pick_slot) - 1):
            info.pickup_movement += abs(pick_slot[idx + 1] - pick_slot[idx])

    if hinter:
        optimization_assign_result(component_data, pcb_data, component_result, cycle_result, feeder_slot_result,
                                   nozzle_hinter=True, component_hinter=False, feeder_hinter=True)

        print('----- Placement machine ' + str(machine_index) + ' ----- ')
        print('-Cycle counter: {}'.format(info.cycle_counter))

        print('-Nozzle change counter: {}'.format(info.nozzle_change_counter))
        print('-Pick operation counter: {}'.format(info.pickup_counter))
        print('-Pick movement: {}'.format(info.pickup_movement))
        print('------------------------------ ')

    # 估算贴装用时
    info.placement_time = placement_time_estimate(component_data, pcb_data, component_result, cycle_result,
                                                  feeder_slot_result, placement_result, head_sequence, hinter=False)
    return info