<?php

namespace App\Http\Controllers\Refactor;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use App\Model\CustomerEmailTemplate;
use App\Model\SystemEmailTemplate;
use App\Model\Template;
use App\Model\TemplateCategory;
use Gate;

class EmailTemplateController extends Controller
{
    /**
     * Template listing page.
     */
    public function index(Request $request)
    {
        if (Gate::denies('list', new CustomerEmailTemplate())) {
            return $this->notAuthorized();
        }

        $customer = $request->user()->customer;
        $totalTemplates = $customer->customerEmailTemplates()->count();
        $categories = TemplateCategory::forEmail()->get();

        return view('refactor.pages.templates.index', compact('totalTemplates', 'categories'));
    }

    /**
     * AJAX listing — grid cards with thumbnails.
     */
    public function listing(Request $request)
    {
        $customer = $request->user()->customer;
        $templates = $customer->customerEmailTemplates();

        if ($request->keyword) {
            $templates = $templates->search($request->keyword);
        }

        if ($request->category_uid) {
            $templates = $templates->categoryUid($request->category_uid);
        }

        $templates = $templates
            ->orderBy($request->sort_order ?: 'created_at', $request->sort_direction ?: 'desc')
            ->paginate($request->per_page ?: 12);

        $view = $request->view === 'list' ? '_list' : '_listing';

        return view('refactor.pages.templates.' . $view, compact('templates'));
    }

    /**
     * Create template — show gallery + name input.
     */
    public function create(Request $request)
    {
        if (Gate::denies('create', new CustomerEmailTemplate())) {
            return $this->notAuthorized();
        }

        $customer = $request->user()->customer;

        if ($request->isMethod('post')) {
            $this->validate($request, ['name' => 'required', 'template' => 'required']);

            $systemTemplate = SystemEmailTemplate::findByUid($request->template);
            if (!$systemTemplate) {
                return redirect()->back()->with('alert-error', 'Template not found.');
            }

            $customerEmailTemplate = new CustomerEmailTemplate();
            $customerEmailTemplate->customer_id = $customer->id;
            \App\Services\TemplateService::for($customerEmailTemplate)
                ->setTemplate($systemTemplate->template, $request->name);

            // Redirect to old builder (complex, separate refactor)
            return redirect()->route('refactor.templates.builder', $customerEmailTemplate->uid);
        }

        $categories = TemplateCategory::forEmail()->get();

        return view('refactor.pages.templates.create', compact('categories'));
    }

    /**
     * AJAX: System template gallery for selection.
     */
    public function gallery(Request $request)
    {
        $templates = SystemEmailTemplate::query();

        if ($request->category_uid) {
            $templates = $templates->categoryUid($request->category_uid);
        }

        if ($request->keyword) {
            $templates = $templates->search($request->keyword);
        }

        $templates = $templates->orderBy('created_at', 'desc')->paginate(12);

        return view('refactor.pages.templates._gallery', compact('templates'));
    }

    /**
     * Preview template HTML.
     */
    public function preview(Request $request)
    {
        $customerTemplate = CustomerEmailTemplate::findByUid($request->uid);

        if (Gate::denies('preview', $customerTemplate)) {
            return $this->notAuthorized();
        }

        return response($customerTemplate->template->getPreviewContent());
    }

    /**
     * Rename template — popup form.
     */
    public function rename(Request $request)
    {
        $customerTemplate = CustomerEmailTemplate::findByUid($request->uid);

        if (Gate::denies('update', $customerTemplate)) {
            return $this->notAuthorized();
        }

        if ($request->isMethod('post')) {
            $this->validate($request, ['name' => 'required']);
            $customerTemplate->name = $request->name;
            $customerTemplate->save();

            return response()->json(['status' => 'success', 'message' => trans('refactor/templates.flash.renamed')]);
        }

        return view('refactor.pages.templates.rename', compact('customerTemplate'));
    }

    /**
     * Copy template — popup form.
     */
    public function copy(Request $request)
    {
        $customerTemplate = CustomerEmailTemplate::findByUid($request->uid);

        if (Gate::denies('copy', $customerTemplate)) {
            return $this->notAuthorized();
        }

        if ($request->isMethod('post')) {
            $this->validate($request, ['name' => 'required']);

            $newCustomerTemplate = new CustomerEmailTemplate();
            $newCustomerTemplate->customer_id = $customerTemplate->customer_id;
            \App\Services\TemplateService::for($newCustomerTemplate)
                ->setTemplate($customerTemplate->template, $request->name);

            return response()->json(['status' => 'success', 'message' => trans('refactor/templates.flash.copied')]);
        }

        return view('refactor.pages.templates.copy', compact('customerTemplate'));
    }

    /**
     * Delete templates.
     */
    public function delete(Request $request)
    {
        $uids = is_array($request->uids) ? $request->uids : explode(',', $request->uids);

        foreach ($uids as $uid) {
            $template = CustomerEmailTemplate::findByUid($uid);
            if ($template && Gate::allows('delete', $template)) {
                $template->deleteAndCleanup();
            }
        }

        return response()->json(['status' => 'success', 'message' => trans('refactor/templates.flash.deleted')]);
    }

    public function builder(Request $request, $uid)
    {
        $customerEmailTemplate = $request->user()->customer->customerEmailTemplates()
            ->where('uid', $uid)->first();

        if (!$customerEmailTemplate) {
            return redirect()->route('refactor.templates.index');
        }

        if (\Gate::denies('update', $customerEmailTemplate)) {
            return $this->notAuthorized();
        }

        // Handle POST (builder save)
        if ($request->isMethod('post')) {
            $validator = $customerEmailTemplate->template->updateContent($request->json, $request->content);

            if ($validator->fails()) {
                return response()->json($validator->errors(), 400);
            }

            return response()->json([
                'status' => 'success',
            ]);
        }

        $templates = $request->user()->customer->getBuilderTemplates();

        return view('refactor.pages.templates.builder', [
            'customerEmailTemplate' => $customerEmailTemplate,
            'templates' => $templates,
        ]);
    }

    public function changeTemplate(Request $request, $uid)
    {
        $customerEmailTemplate = $request->user()->customer->customerEmailTemplates()
            ->where('uid', $uid)->first();

        if (!$customerEmailTemplate) {
            return response()->json(['error' => 'Not found'], 404);
        }

        if (Gate::denies('update', $customerEmailTemplate)) {
            return response()->json(['error' => 'Forbidden'], 403);
        }

        $fromTemplate = Template::findByUid($request->template_uid);
        if (!$fromTemplate) {
            return response()->json(['error' => 'Source template not found'], 404);
        }

        $customerEmailTemplate->template->applyTemplateFrom($fromTemplate);

        return response()->json(['status' => 'success']);
    }
}