<?php

namespace App\Http\Controllers;

use App\Models\ClinicIdentity;
use Illuminate\Http\Request;
use App\Exceptions\GlobalException;
use Throwable;
use Illuminate\Support\Facades\Storage;

class ClinicIdentityController extends Controller
{
    /**
     * Constructor para verificar automáticamente el enlace simbólico
     */
    public function __construct()
    {
        $this->checkAndCreateStorageLink();
    }

    /**
     * Verifica y crea el enlace simbólico automáticamente si no existe
     */
    private function checkAndCreateStorageLink()
    {
        try {
            $publicPath = public_path('storage');
            
            // Si el enlace no existe, crearlo automáticamente
            if (!file_exists($publicPath)) {
                // Crear el directorio storage en public si no existe
                if (!file_exists(dirname($publicPath))) {
                    mkdir(dirname($publicPath), 0755, true);
                }
                
                // Crear el enlace simbólico
                if (PHP_OS_FAMILY === 'Windows') {
                    // En Windows, usar el comando de symlink nativo o junction
                    exec('mklink /J "' . public_path('storage') . '" "' . storage_path('app/public') . '"');
                } else {
                    // En Unix/Linux, usar symlink()
                    symlink(storage_path('app/public'), public_path('storage'));
                }
            }
        } catch (Throwable $th) {
            // Silenciar error pero loguearlo para que el administrador lo vea
            \Log::error('Error al crear automáticamente el enlace simbólico: ' . $th->getMessage());
        }
    }

    /**
     * Muestra la lista de identidades del consultorio
     */
    public function index()
    {
        try {
            $identities = ClinicIdentity::all();
            return view('clinic-identity.index', compact('identities'));
        } catch (Throwable $th) {
            throw new GlobalException($th->getMessage());
        }
    }

    /**
     * Muestra el formulario para crear una nueva identidad
     */
    public function create()
    {
        try {
            return view('clinic-identity.create');
        } catch (Throwable $th) {
            throw new GlobalException($th->getMessage());
        }
    }

    /**
     * Almacena una nueva identidad en la base de datos
     */
    public function store(Request $request)
    {
        try {
            $validated = $request->validate([
                'name' => 'required|string|max:255',
                'address' => 'required|string',
                'phone' => 'nullable|string|max:20',
                'email' => 'nullable|email|max:255',
                'tax_id' => 'nullable|string|max:50',
                'logo' => 'nullable|image|mimes:jpeg,png,jpg,gif|max:2048',
                'website' => 'nullable|url|max:255',
                'description' => 'nullable|string',
                'specialty' => 'nullable|string|max:255',
                'social_media_links' => 'nullable|string|max:255',
                'working_hours' => 'nullable|string|max:255',
                'emergency_contact' => 'nullable|string|max:255',
            ]);

            $data = $validated;
            
            // Manejar la carga del logo si se proporciona
            if ($request->hasFile('logo')) {
                $logoPath = $request->file('logo')->store('logos', 'public');
                $data['logo_path'] = $logoPath;
            }

            $clinicIdentity = ClinicIdentity::create($data);

            // Si se marca como activa, desactivar las demás
            if ($request->has('is_active') && $request->is_active) {
                $clinicIdentity->setAsActive();
            }

            return redirect()
                ->route('clinic-identity.index')
                ->with('success', __('La identidad del consultorio ha sido creada exitosamente.'));
        } catch (Throwable $th) {
            throw new GlobalException($th->getMessage());
        }
    }

    /**
     * Muestra el formulario para editar una identidad existente
     */
    public function edit($id)
    {
        try {
            $identity = ClinicIdentity::findOrFail($id);
            return view('clinic-identity.edit', compact('identity'));
        } catch (Throwable $th) {
            throw new GlobalException($th->getMessage());
        }
    }

    /**
     * Actualiza la identidad en la base de datos
     */
    public function update(Request $request, $id)
    {
        try {
            $identity = ClinicIdentity::findOrFail($id);

            $validated = $request->validate([
                'name' => 'required|string|max:255',
                'address' => 'required|string',
                'phone' => 'nullable|string|max:20',
                'email' => 'nullable|email|max:255',
                'tax_id' => 'nullable|string|max:50',
                'logo' => 'nullable|image|mimes:jpeg,png,jpg,gif|max:2048',
                'website' => 'nullable|url|max:255',
                'description' => 'nullable|string',
                'specialty' => 'nullable|string|max:255',
                'social_media_links' => 'nullable|string|max:255',
                'working_hours' => 'nullable|string|max:255',
                'emergency_contact' => 'nullable|string|max:255',
            ]);

            $data = $validated;
            
            // Manejar la carga del logo si se proporciona
            if ($request->hasFile('logo')) {
                // Eliminar el logo antiguo si existe
                if ($identity->logo_path) {
                    Storage::disk('public')->delete($identity->logo_path);
                }
                
                $logoPath = $request->file('logo')->store('logos', 'public');
                $data['logo_path'] = $logoPath;
            }

            $identity->update($data);

            // Si se marca como activa, desactivar las demás
            if ($request->has('is_active') && $request->is_active) {
                $identity->setAsActive();
            }

            return redirect()
                ->route('clinic-identity.index')
                ->with('success', __('La identidad del consultorio ha sido actualizada exitosamente.'));
        } catch (Throwable $th) {
            throw new GlobalException($th->getMessage());
        }
    }

    /**
     * Elimina la identidad de la base de datos
     */
    public function destroy($id)
    {
        try {
            $identity = ClinicIdentity::findOrFail($id);
            
            // Eliminar el logo si existe
            if ($identity->logo_path) {
                Storage::disk('public')->delete($identity->logo_path);
            }
            
            $identity->delete();
            
            return redirect()
                ->route('clinic-identity.index')
                ->with('success', __('La identidad del consultorio ha sido eliminada exitosamente.'));
        } catch (Throwable $th) {
            throw new GlobalException($th->getMessage());
        }
    }

    /**
     * Establece una identidad como activa
     */
    public function setActive($id)
    {
        try {
            $identity = ClinicIdentity::findOrFail($id);
            $identity->setAsActive();
            
            return redirect()
                ->route('clinic-identity.index')
                ->with('success', __('La identidad del consultorio ha sido establecida como activa.'));
        } catch (Throwable $th) {
            throw new GlobalException($th->getMessage());
        }
    }

    /**
     * Crea manualmente el enlace simbólico para el almacenamiento
     * Esta función ahora es solo de respaldo y no debería usarse normalmente
     */
    public function createStorageLink()
    {
        try {
            // Obtener la ruta del directorio de almacenamiento público
            $publicPath = public_path('storage');
            
            // Comprobar si el enlace ya existe
            if (file_exists($publicPath)) {
                return redirect()
                    ->route('clinic-identity.index')
                    ->with('success', 'El enlace simbólico de almacenamiento ya existe.');
            }
            
            // Crear el directorio storage en public si no existe
            if (!file_exists(dirname($publicPath))) {
                mkdir(dirname($publicPath), 0755, true);
            }
            
            // Crear el enlace simbólico
            if (PHP_OS_FAMILY === 'Windows') {
                // En Windows, usar el comando de symlink nativo o junction
                exec('mklink /J "' . public_path('storage') . '" "' . storage_path('app/public') . '"');
            } else {
                // En Unix/Linux, usar symlink()
                symlink(storage_path('app/public'), public_path('storage'));
            }
            
            return redirect()
                ->route('clinic-identity.index')
                ->with('success', 'El enlace simbólico de almacenamiento se ha creado correctamente.');
        } catch (Throwable $th) {
            return redirect()
                ->route('clinic-identity.index')
                ->with('error', 'Error al crear el enlace simbólico: ' . $th->getMessage());
        }
    }
} 