<?php

namespace App\Http\Controllers;

use App\Models\ConstructionWorkstation;
use App\Models\ControlEquipmentWorkstation;
use App\Models\ElementalTasks;
use App\Models\Equipment;
use App\Models\OrderEquipmentTasks;
use App\Models\workstationsTaskAnswers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;


class WorkstationsJobsController extends Controller
{
    public function receiveAnswersEquipment(Request $request)
    {
        //Deve recber o id da control atual. 
        // Primeiro ele deve criar a  associação entre id atual do control + perguntas e respostas  
        $receiveAnswersElementalTasks = new workstationsTaskAnswers;
        $receiveAnswersElementalTasks->control_equipment_workstation_id = $request->controlEquipmentID;

        // Inicializando o array que vai armazenar os objetos JSON
        $answersArray = []; // Array para armazenar as respostas

        // Iterar sobre o array externo
        foreach ($request->all() as $idKey => $subArray) {
            // Verificar se a chave atual é uma das chaves de ID (ID1, ID2, etc.)
            if (strpos($idKey, 'ID') === 0 && is_array($subArray)) {
                // Iterar sobre o array interno
                foreach ($subArray as $key => $value) {
                    // Ignorando a chave control_equipment_workstation_id
                    if ($key !== 'controlEquipmentID') {
                        // Verificando se $key contém '-'
                        if (strpos($key, '-') !== false) {
                            // Dividindo a chave em duas partes: question e type
                            list($question, $type) = explode('-', $key);

                            // Adicionando um novo objeto JSON ao array
                            $answersArray[] = [
                                'type' => $type,
                                'value' => $value,
                                'question' => $question,
                                'idKey' => $idKey // Adicionando a chave do ID se necessário
                            ];
                        }
                    }
                }
            }
        }

        // Convertendo o array em uma string JSON
        $jsonString = json_encode($answersArray);

        // Armazenando a string JSON no banco de dados
        $receiveAnswersElementalTasks->answer_json = $jsonString;

        // Busca a Ws com base no id recebido da tabela Control.
        $recebeDataControlWs = ControlEquipmentWorkstation::find($request->controlEquipmentID);
        $recebeDataControlWs->departure_date = now();

        $requestData = $request->all();

        // Iterar sobre o array de parâmetros do request
        foreach ($requestData as $key => $value) {
            if (preg_match('/^ID(\d+)$/', $key, $matches)) {
                // $matches[1] contém o número após 'ID'
                $idNumber = $matches[1];
                // Atribuir o número extraído diretamente ao elemental_tasks_id
                $recebeDataControlWs->elemental_tasks_id = $idNumber;
                break; // Se você só espera um ID, pare o loop depois de encontrar
            }
        }

        // Primeiro adicionamos a tarefa que acabou de completar, em seguida salvamos a respostas recebidas. 
        $recebeDataControlWs->save();
        $receiveAnswersElementalTasks->save();

        // Agora que guardamos os dados anteriores, vamos criar a nova linha na tabela Control Equipment ID para que o equipamento continue
        $newControlEquipment = new ControlEquipmentWorkstation;
        $newControlEquipment->equipment_id = $recebeDataControlWs->equipment_id;
        $newControlEquipment->id_workstations = $recebeDataControlWs->id_workstations;
        $newControlEquipment->entry_date = now();
        $newControlEquipment->save();

        // Vamos buscar os dados da tarefa elementar comcluida para mandar uma mensagem ao Front e indicar que esta completada
        $receiveDataElementalTask = ElementalTasks::find($recebeDataControlWs->elemental_tasks_id,'elemental_tasks_id')->first();

        return back()->with('success', 'Tarefa :: '.$receiveDataElementalTask->elemental_tasks_code.'-'.$receiveDataElementalTask->elemental_tasks_code.' Concluída com sucesso!');

        // return route('getEquipmentData', $recebeDataControlWs->equipment_id);

    }

    // Ao selecionar o equipamento para se inicializar a tarefa deve mostrar os dados relacionados.
    public function getEquipmentData($equipment_id)
    {
        //vai receber o email atual, no caso o da workstation que se encontra 
        $userEmail = Auth::user();
        // Busca os dados da Ws com base no Login
        $receiveDataWs = ConstructionWorkstation::where('name_workstations', $userEmail->user_name)->first();

        // Recebe os dados do Equipamento 
        $receiveDataEquipment = Equipment::where('equipment_id', $equipment_id)->first();
        // Recebe todas as tarefas elementares do equipamento.
        $recebeTasksForEquipment = OrderEquipmentTasks::where('equipment_id', $equipment_id)->get();

        // Primeira coisa, deve verificar se existe dados deste equipamento e se suas coluna elemental_tasks_id e departure_date estao diferentes de null
        // Se estiver diferente de null quer dizer que todas as tarefas anteriores deste equipamento ja foram realizadas e se ele ainda aparece na tabela de equipamentos por fazer que dizer que ele ainda nao terminou todas as suas tarefas.
        $existingControlEquipment = ControlEquipmentWorkstation::where('equipment_id', $receiveDataEquipment->equipment_id)
            ->whereNull('elemental_tasks_id')
            ->whereNull('departure_date')
            ->first();

        $receiveDataControlEquipment = $existingControlEquipment;

        // Ele realmente cria dados, porem toda a vez que da reload ele continua a criar.
        // Ao entrar na tela do equipamento deve criar dados, para ele nao poder ser buscado por nenhuma outra WS.
        if (!$existingControlEquipment) {
            $createControlEquipment = new ControlEquipmentWorkstation;
            $createControlEquipment->equipment_id = $receiveDataEquipment->equipment_id;
            $createControlEquipment->id_workstations = $receiveDataWs->id_workstations;
            $createControlEquipment->entry_date = now();
            $createControlEquipment->save();

            $receiveDataControlEquipment = $createControlEquipment;
        }


        //Busca as tarefas que podem ser feitas pela WS Atual a partir do Email 
        $userTasks = DB::table('users as u')
            ->join('construction_workstations as cw', 'u.user_name', '=', 'cw.name_workstations')
            ->join('workstations_association_tasks as wat', 'cw.id_workstations', '=', 'wat.id_workstations')
            ->where('u.email', $userEmail->email)
            ->select('cw.id_workstations', 'cw.name_workstations', DB::raw('GROUP_CONCAT(COALESCE(wat.elemental_tasks_id, wat.further_tasks_id)) AS all_tasks'))
            ->groupBy('cw.id_workstations', 'cw.name_workstations')
            ->get();

        // Primeiro, obtenha todos os IDs de tarefas elementares e outras tarefas de $userTasks
        $userTasksIds = $userTasks->pluck('all_tasks')->map(function ($tasks) {
            // Transforma a string 'all_tasks' em um array e remove espaços em branco
            return array_map('trim', explode(',', $tasks));
        })->flatten()->unique();

        // Em seguida, obtenha todos os IDs de tarefas elementares de $recebeTasksForEquipment
        $equipmentTasksIds = $recebeTasksForEquipment->pluck('elemental_tasks_id')->filter()->unique();

        // Agora, compare os dois conjuntos de IDs para encontrar os IDs comuns
        $commonIds = $equipmentTasksIds->intersect($userTasksIds);

        //recebe as tarefas que a Ws atual pode fazer. 
        $divisionElementalTasks = [
            1 => $commonIds->all(),
        ];

        // IDs que estão em $recebeTasksForEquipment mas não em $userTasks
        $uniqueEquipmentTasksIds = $equipmentTasksIds->diff($userTasksIds);

        // Adicione esses IDs únicos ao array $divisionElementalTasks na chave [2]
        $divisionElementalTasks[2] = $uniqueEquipmentTasksIds->all();


        // Primeiro, obtenha o registro de ControlEquipmentWorkstation que não deve ter 'elemental_tasks_id' e 'departure_date' como null
        $completedTasks = ControlEquipmentWorkstation::where('equipment_id', $equipment_id)
            ->whereNotNull('elemental_tasks_id')
            ->whereNotNull('departure_date')
            ->pluck('elemental_tasks_id')->toArray(); // Supondo que você quer apenas os IDs das tarefas

        // Agora, verifique se algum desses IDs está em $divisionElementalTasks[1] e mova para $divisionElementalTasks[3]
        foreach ($completedTasks as $completedTaskId) {
            if (in_array($completedTaskId, $divisionElementalTasks[1])) {
                // Encontre a chave do valor correspondente em [1]
                $key = array_search($completedTaskId, $divisionElementalTasks[1]);

                // Mova a tarefa de [1] para [3]
                $divisionElementalTasks[3][$key] = $completedTaskId;

                // Remova a tarefa de [1]
                unset($divisionElementalTasks[1][$key]);
            }
        }

        $recebeTasksForEquipment->map(function ($task) use ($divisionElementalTasks) {
            // Verifica se o id da tarefa está no array de tarefas que podem ser feitas
            if (in_array($task->elemental_tasks_id, $divisionElementalTasks[1])) {
                $task->cardType = 'card-primary';
            }
            // Verifica se o id da tarefa está no array de tarefas que não podem ser feitas
            elseif (in_array($task->elemental_tasks_id, $divisionElementalTasks[2])) {
                $task->cardType = 'card-warning';
            }
            // Verifica se o id da tarefa está no array de tarefas já feitas
            elseif (in_array($task->elemental_tasks_id, $divisionElementalTasks[3])) {
                $task->cardType = 'card-info';
            }
            // Se não estiver em nenhum dos arrays, define um tipo padrão (opcional)
            else {
                $task->cardType = 'card-warning'; // ou qualquer outra classe que você queira usar como padrão
            }

            return $task;
        });

        // dd($divisionElementalTasks);

        return view('workstations.workstations', [
            'receiveDataEquipment' => $receiveDataEquipment,
            'receiveDataControlEquipment' => $receiveDataControlEquipment,

            'recebeTasksForEquipment' => $recebeTasksForEquipment,
            'divisionElementalTasks' => $divisionElementalTasks,
        ]);


        // Busca os Equipamento com base nas tarefas que a Ws atual pode fazer. 
        // Nao sei de ainda va ser usado apos a atualizacao.
        // $equipmentTasks = DB::table('users as u')
        //     ->join('construction_workstations as cw', 'u.user_name', '=', 'cw.name_workstations')
        //     ->join('workstations_association_tasks as wat', 'cw.id_workstations', '=', 'wat.id_workstations')
        //     ->join('equipments as e', 'wat.company_projects_id', '=', 'e.company_projects_id')
        //     ->join('ordered_equipment_tasks as oet', 'e.equipment_id', '=', 'oet.equipment_id')
        //     ->where('u.email', $userEmail->email)
        //     ->select('e.equipment_id', 'e.equipment_tag', DB::raw('GROUP_CONCAT(DISTINCT COALESCE(oet.elemental_tasks_id, oet.further_tasks_id) ORDER BY oet.execution_order) AS equipment_all_tasks'))
        //     ->groupBy('e.equipment_id', 'e.equipment_tag')
        //     ->orderBy('e.equipment_id', 'ASC')
        //     ->get();
        // Convertendo as tarefas do usuário(WS) em um array
        // $tasksArray = explode(',', $userTasks->pluck('all_tasks')->first());
    }


    public function cancelElementalTaskForEquipment($equipmentID)
    {
        //Nesta funcao se o utilizador da Ws apenas o botao de cancelar na view principal,o equipamento deve se desvincular na Ws atual e poder ser selecionado por outra.
        $receiveDataEquipment = Equipment::where('equipment_id', $equipmentID)->first();

        $existingControlEquipment = ControlEquipmentWorkstation::where('equipment_id', $receiveDataEquipment->equipment_id)
            ->whereNull('elemental_tasks_id')
            ->whereNull('departure_date')
            ->first();
        $existingControlEquipment->delete();
        return redirect(route('enterWorkstation'));
    }
}