<?php

namespace App\Http\Controllers;

use App\Models\ConstructionWorkstation;
use App\Models\ControlEquipmentWorkstation;
use App\Models\ElementalTasks;
use App\Models\Equipment;
use App\Models\EquipmentComment;
use App\Models\EquipmentWorkHistory;
use App\Models\OrderEquipmentTasks;
use App\Models\workstationsTaskAnswers;
use App\Models\ReceiveImagesControlEquipmentWorkstation; // Ajuste o namespace conforme necessário

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

use Mockery\Undefined;


class WorkstationsJobsController extends Controller
{
    public function updateSessionStatus(Request $request, $controlEquipmentId)
    {

        $controlEquipment = ControlEquipmentWorkstation::find($controlEquipmentId);
        if ($controlEquipment) {
            $controlEquipment->status = $request->input('status', 1); // Assume 1 como padrão para sessão ativa
            $controlEquipment->last_active_at = now(); // Atualiza o timestamp da última atividade
            $controlEquipment->save();

            return response()->json(['success' => true, 'message' => 'Sessão atualizada com sucesso.']);
        }

        return response()->json(['success' => false, 'message' => 'Equipamento não encontrado.']);
    }


    public function receiveQuestionsEquipment($equipmentID)
    {
        //Busca os valores do historico do equipamento
        $receiveWorkHistoryEquipment = EquipmentWorkHistory::where('equipment_id', $equipmentID)->first();

        // Se nao encontrar, retorna mensagem de erro. 
        if (!$receiveWorkHistoryEquipment) {
            return response()->json(['message' => 'Equipment Work History not found'], 404);
        }
        //Se encontrar verifica na ControlEquipmentWorkstation dados referentes ao equipamento que faz a tarefa TE3(2)-CV e tem o departure_date mais recente 
        $mostRecentTask = ControlEquipmentWorkstation::where('equipmentWorkHistorys_id', $receiveWorkHistoryEquipment->equipmentWorkHistorys_id)
            ->where('elemental_tasks_id', 4)
            ->whereNotNull('departure_date')
            ->orderBy('departure_date', 'desc')
            ->first();

        // Se nao encontrar, retorna mensagem de erro. 
        if (!$mostRecentTask) {
            return response()->json(['message' => 'No recent task found'], 404);
        }

        $workstationTaskAnswers = WorkstationsTaskAnswers::where('control_equipment_workstation_id', $mostRecentTask->control_equipment_workstation_id)->get();


        $interestedQuestions = ['valve_repair', 'actuator_repair', 'repair_positioner'];
        $answersWithYes = [];

        foreach ($workstationTaskAnswers as $answer) {
            $answerJson = json_decode($answer->answer_json, true);

            foreach ($answerJson as $item) {
                if (in_array($item['question'], $interestedQuestions) && $item['value'] === 'yes') {
                    $answersWithYes[] = ['question' => $item['question']];
                }
            }
        }

        return response()->json($answersWithYes);
    }
    public function receiveAnswersEquipment(Request $request, $control_equipment_workstation_id)
    {
        
        //No request recebemos ID(NUmero da tarela elementar) , esta variavel vai receber este ID apos selerar o id da string
        // $elementalTaskID = 0;
        // Deve receber as perguntas e respostas para a tarefa selecionada
        $requestData = $request->all();

        // Verifica se há pelo menos um campo que começa com 'ID'
        $hasIDKey = false;
        foreach ($requestData as $key => $value) {
            if (preg_match('/ID(\d+)/', $key, $matches)) {
                $hasIDKey = true;
                $elementalTaskID = intval($matches[1]);
                break;  // Sai do loop após encontrar o primeiro match
            }
        }


        // Se não encontrou nenhuma chave 'ID', redireciona de volta com uma mensagem de erro
        if (!$hasIDKey) {
            return redirect()->back()->with('danger', 'A última tarefa não foi salva. Respostas incorretas ou irregulares.');
        }

        // Ele deve criar a associação entre id atual do control + perguntas e respostas  
        $receiveAnswersElementalTasks = new WorkstationsTaskAnswers;
        $receiveAnswersElementalTasks->control_equipment_workstation_id = $control_equipment_workstation_id;

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

        // Iterar sobre o array externo
        foreach ($requestData 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.
        $receiveDataControlWs = ControlEquipmentWorkstation::find($control_equipment_workstation_id);

        $receiveDataControlWs->elemental_tasks_id = $elementalTaskID;
        $receiveDataControlWs->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
                $receiveDataControlWs->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. 
        $receiveDataControlWs->save();
        $receiveAnswersElementalTasks->save();

        if ($request->capturedImages) {
            $imagesBase64 = json_decode($request->capturedImages);
            $imagePaths = [];

            // Obtenha ou defina $receiveDataControlWs conforme sua lógica de negócio
            $folderName = $receiveDataControlWs->control_equipment_workstation_id . '_' . $receiveDataControlWs->equipmentWorkHistorys_id;

            // Define o caminho da pasta onde as imagens serão salvas
            $path = public_path('receiveImagesControlEquipmentWorkstation/' . $folderName);

            // Cria a pasta se não existir
            if (!File::isDirectory($path)) {
                File::makeDirectory($path, 0777, true, true);
            }

            foreach ($imagesBase64 as $index => $imageBase64) {
                list($type, $imageBase64) = explode(';', $imageBase64);
                list(, $imageBase64) = explode(',', $imageBase64);
                $imageData = base64_decode($imageBase64);

                // Define um nome de arquivo baseado no índice
                $fileName = 'img' . ($index + 1) . '.png';

                // Caminho completo do arquivo
                $fullPath = $path . '/' . $fileName;

                // Salva a imagem
                file_put_contents($fullPath, $imageData);

                // Armazena o caminho relativo da imagem no array
                $imagePaths[] = 'receiveImagesControlEquipmentWorkstation/' . $folderName . '/' . $fileName;
            }

            // Salva o array de caminhos de imagem como JSON na base de dados
            $model = new ReceiveImagesControlEquipmentWorkstation(); // Ajuste conforme seu modelo
            $model->control_equipment_workstation_id = $receiveDataControlWs->control_equipment_workstation_id;
            $model->image_paths = json_encode($imagePaths);
            $model->save();
        }

        // Vamos buscar os dados da tarefa elementar comcluida para mandar uma mensagem ao Front e indicar que esta completada
        $receiveDataElementalTask = ElementalTasks::find($receiveDataControlWs->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, $component_tag)
    {
        //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();


        $tagType = explode('@', $component_tag)[1]; // Isola o tipo da tag após o '@'


        // Busca os dados do equipamento
        $receiveEquipmentWorkHistory = EquipmentWorkHistory::where('equipment_id', $receiveDataEquipment->equipment_id)
            ->where('company_projects_id', $receiveDataEquipment->company_projects_id)
            ->first();

        if ($receiveEquipmentWorkHistory && $receiveEquipmentWorkHistory->equipment_status_project == 2) {
            return redirect()->back()->with('danger', 'O equipamento já está concluído');
        }

        $equipmentInUse = ControlEquipmentWorkstation::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_id)
            ->whereNull('departure_date') // A data de saída deve ser nula, indicando que a tarefa ainda está ativa
            ->whereNotNull('id_workstations') // Deve ter um posto de trabalho associado
            ->where('id_workstations', '!=', $receiveDataWs->id_workstations) // E esse posto de trabalho não deve ser o atual
            ->where(function ($query) use ($tagType) {
                if ($tagType == 'Obturador') {
                    // Apenas se a tarefa for igual a 9, indicando uma tarefa de Obturador
                    $query->where('elemental_tasks_id', '=', 9);
                } elseif ($tagType == 'Corpo') {
                    // Apenas se a tarefa for NULL, indicando uma tarefa de Corpo que não foi especificada
                    $query->whereNull('elemental_tasks_id');
                }
            })
            ->where('status', 1) // O status deve indicar que está ativo
            ->whereNotNull('entry_date') // Deve ter uma data de entrada, indicando que a tarefa foi iniciada
            ->exists(); // Verifica se existe ao menos um registro que atenda às condições


        // Se o equipamento já estiver em uso, redirecione com uma mensagem de erro
        if ($equipmentInUse) {
            return redirect()->back()->with('danger', 'O equipamento já se encontra a executar tarefas noutro posto de trabalho.');
        }


        // Recebe todas as tarefas elementares do equipamento.
        $recebeTasksForEquipment = OrderEquipmentTasks::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_id)
            ->orderBy('execution_order', 'asc')
            ->get();


        //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)) 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
        $comparisonBetweenBothTasks = $equipmentTasksIds->intersect($userTasksIds);

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

        // IDs que estão em $recebeTasksForEquipment mas não em $userTasks ou seja sao os ids que a Ws nao pode executar estas tarefas.
        $receiveTasksThatCannotBeDone = $equipmentTasksIds->diff($userTasksIds);
        // Adicione esses IDs únicos ao array $divisionElementalTasks na chave [2]
        $divisionElementalTasks[2] = $receiveTasksThatCannotBeDone->all();

        $existingDataControlEquipment = null;


        // Inicia a consulta baseada no tipo de tag
        $query = ControlEquipmentWorkstation::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_id)
            ->whereNull('departure_date')
            ->where('status', 1); // Suponho que você deseja apenas registros ativos

        // Adiciona condições específicas baseadas no tipo de tag
        if ($tagType == 'Obturador') {
            // Procura por registros com elemental_tasks_id = 9
            $query->where('elemental_tasks_id', 9);
        } elseif ($tagType == 'Corpo') {
            // Procura por registros com elemental_tasks_id NULL
            $query->whereNull('elemental_tasks_id');
        }
        // Se encontrar Dados nestas condicoes, provavelmente, se refere a Uma atualizacao na pagina atual 
        if ($query->first()) {

            $existingDataControlEquipment = $query->first();

            // Caso nao seja uma possivel atualizacao, antes de criar um dado novo, deve verificar, se exsite um control_equipment_workstation_id, que nao estaja em uso para este equipamento.
        } else {

            $query = ControlEquipmentWorkstation::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_id)
                ->whereNull('departure_date')
                ->orderByDesc('departure_date') // Ordena por departure_date de forma decrescente
                ->where('status', 0)
                ->whereNull('id_workstations')
                ->whereNull('elemental_tasks_id');

            if ($query->first()) {

                $existingDataControlEquipment = $query->first();
            }
        }
        // Verifica se um registro foi encontrado e atualiza conforme necessário
        if ($existingDataControlEquipment) {

            $existingDataControlEquipment->id_workstations = $receiveDataWs->id_workstations;
            $existingDataControlEquipment->entry_date = now();
            $existingDataControlEquipment->status = 1;
            $existingDataControlEquipment->last_active_at = now();

            // Se a tag for 'Obturador', atualiza o elemental_tasks_id se nao deixa como NULL
            if ($tagType == 'Obturador') {
                $existingDataControlEquipment->elemental_tasks_id = 9;
            }
            $existingDataControlEquipment->save();
            $receiveDataControlEquipment = $existingDataControlEquipment;

        } else {
            // Nenhum registro existente encontrado, crie um novo
            $newDataControlEquipment = new ControlEquipmentWorkstation;
            $newDataControlEquipment->equipmentWorkHistorys_id = $receiveEquipmentWorkHistory->equipmentWorkHistorys_id;
            $newDataControlEquipment->id_workstations = $receiveDataWs->id_workstations;
            $newDataControlEquipment->entry_date = now();

            if (strpos($component_tag, '@Obturador') !== false) {
                $newDataControlEquipment->elemental_tasks_id = 9;
            }

            $newDataControlEquipment->status = 1;
            $newDataControlEquipment->save();

            $receiveDataControlEquipment = $newDataControlEquipment;
        }

        // Primeiro, obtenha o registro de ControlEquipmentWorkstation que não deve ter 'elemental_tasks_id' e 'departure_date' como null
        $completedTasks = ControlEquipmentWorkstation::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_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]
        //O id que for movido para o [3] sua inica condicao sera quando o 'entry_date' e 'departure_date' forem diferentes de null, assim indica ser uma tarefa Finalizada.
        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';
                $task->cardTypeStyle = 'blue';  // Define o estilo de cor

            }
            // 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-primary';
                $task->cardTypeStyle = 'gray';  // Define o estilo de cor

                // Consulta ControlEquipmentWorkstation para verificar as condições especificadas
                $controlEquipment = ControlEquipmentWorkstation::where('elemental_tasks_id', $task->elemental_tasks_id)
                    ->whereNotNull('entry_date')
                    ->whereNotNull('departure_date')
                    ->orderByDesc('departure_date') // Ordena por departure_date de forma decrescente
                    ->first();

                if ($controlEquipment) {
                    // Se encontrar, atribuir control_equipment_workstation_id
                    $task->control_equipment_workstation_id = $controlEquipment->control_equipment_workstation_id;

                    //buscar dados na model workstationsTaskAnswers
                    $workstationTaskAnswer = WorkstationsTaskAnswers::where('control_equipment_workstation_id', $task->control_equipment_workstation_id)
                        ->first();

                    if ($workstationTaskAnswer) {
                        // Decodifica o JSON para um array
                        $answersArray = json_decode($workstationTaskAnswer->answer_json, true);

                        // Cria um array associativo onde as chaves são as perguntas e os valores são as respostas
                        $formattedAnswers = [];
                        foreach ($answersArray as $item) {
                            $formattedAnswers[$item['question']] = $item['value'];
                        }

                        // Atribui o array formatado ao task
                        $task->formatted_answers = $formattedAnswers;
                    }

                }

            }

            // 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';
                $task->cardTypeStyle = 'green';  // Define o estilo de cor

                // Consulta ControlEquipmentWorkstation para verificar as condições especificadas
                $controlEquipment = ControlEquipmentWorkstation::where('equipmentWorkHistorys_id', $task->equipmentWorkHistorys_id)
                    ->where('elemental_tasks_id', $task->elemental_tasks_id)
                    ->whereNotNull('entry_date')
                    ->whereNotNull('departure_date')
                    ->orderByDesc('departure_date') // Ordena por departure_date de forma decrescente
                    ->first();

                if ($controlEquipment) {
                    // Se encontrar, atribuir control_equipment_workstation_id
                    $task->control_equipment_workstation_id = $controlEquipment->control_equipment_workstation_id;

                    //buscar dados na model workstationsTaskAnswers
                    $workstationTaskAnswer = WorkstationsTaskAnswers::where('control_equipment_workstation_id', $task->control_equipment_workstation_id)
                        ->first();

                    if ($workstationTaskAnswer) {
                        // Decodifica o JSON para um array
                        $answersArray = json_decode($workstationTaskAnswer->answer_json, true);

                        // Cria um array associativo onde as chaves são as perguntas e os valores são as respostas
                        $formattedAnswers = [];
                        foreach ($answersArray as $item) {
                            $formattedAnswers[$item['question']] = $item['value'];
                        }

                        // Atribui o array formatado ao task
                        $task->formatted_answers = $formattedAnswers;
                    }
                }
            }
            return $task;
        });

        
        // Verificar se component_tag contém '@Obturador' 
        if (strpos($component_tag, '@Obturador') !== false) {
            // Filtrar para manter apenas a tarefa : elemental_tasks_id = 9 (Retificação e lapidação)
            $recebeTasksForEquipment = $recebeTasksForEquipment->filter(function ($task) {
                return $task->elemental_tasks_id == 9;
            });
        } else {
            //Se a Tag nao contém '@Obturador' significa que e um '@Corpo' sendo assim vai ser organizado o Menor para o maior entre as tarefas de acordo com o elemental_tasks_id
            // Alem de remover o 'elemental_tasks_id == 9' das tarefas, pois se é o corpo, nao faz sentido fazer a tarefas de (Retificação e lapidação), sendo assim para realizar esta tarefa so se entrar com a 'TAG de Obturador'. 
            $recebeTasksForEquipment = $recebeTasksForEquipment->reject(function ($task) {
                return $task->elemental_tasks_id == 9;
            })->sortBy('elemental_tasks_id');

            // ordenação de forma geral as tarefas do menor ao maior elemental_tasks_id
            $recebeTasksForEquipment = $recebeTasksForEquipment->sortBy('execution_order');
        }

        $receiveComments = EquipmentComment::with(['user'])
            ->where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_id)
            ->where('company_projects_id', $receiveDataEquipment->company_projects_id)
            ->get()
            ->transform(function ($comment) {
                // Adiciona uma nova propriedade ao objeto de comentário
                $comment->type_users = $comment->user->type_users;
                return $comment;
            });


        return view('workstations.workstations', [
            // Deve receber o atual COntrol ID ? tudo a vez que atualizar ??
            'receiveComments' => $receiveComments,
            'dataControlEquipment' => $receiveDataControlEquipment,
            'receiveDataEquipment' => $receiveDataEquipment,
            'recebeTasksForEquipment' => $recebeTasksForEquipment,
            'receiveComponentTag' => $component_tag
            // 'divisionElementalTasks' => $divisionElementalTasks,
        ]);
    }

    public function cancelElementalTaskForEquipment($controlEquipmentID)
    {
        //Nesta funcao se o utilizador da Ws utilizar o botao cancelar na view principal,o equipamento deve se desvincular na Ws atual e poder ser selecionado por outra.
        // Assim sendo mais pratico excluindo o ultimo dado desta Ws da tabela control_equipment_workstation, quando seu 'elemental_tasks_id' e 'departure_date' forem 'Null'
        // $receiveDataEquipment = Equipment::where('equipment_id', $equipmentID)->first();

        $receiveControlEquipmentID = ControlEquipmentWorkstation::where('control_equipment_workstation_id', $controlEquipmentID)->first();

        if ($receiveControlEquipmentID) {

            $receiveControlEquipmentID->id_workstations = null;
            $receiveControlEquipmentID->elemental_tasks_id = null;
            $receiveControlEquipmentID->status = 0;
            $receiveControlEquipmentID->entry_date = null;
            $receiveControlEquipmentID->save();

        }

        return redirect(route('enterWorkstation'));

    }
}