<?php

namespace App\Http\Controllers\Blogs;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use App\Http\Controllers\Controller;
use App\Model\Master\Blogs\Blog;
use App\Model\Master\Blogs\Tag;
use App\Model\Master\Blogs\Industry;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Str;

use Illuminate\Support\Facades\Log;
use Illuminate\Validation\Rule;

class BlogsController extends Controller
{
  public function blogwithtags(Request $request)
{
    try {
        $connection = "master";

        // Fetch blogs with tags + pagination
        $blogs = Blog::on($connection)
            ->with('tags')
            ->orderBy('created_at', 'desc')
            ->paginate(9);

        return response()->json([
            'success' => true,
            'message' => "Blogs fetched",
            'data' => $blogs
        ], 200);

    } catch (\Exception $e) {
        return response()->json([
            'success' => false,
            'message' => "Error",
            'error' => $e->getMessage()
        ], 500);
    }
}
  public function fetchblogs(Request $request)
{
    try {
        $connection = "master";

        // Fetch blogs with tags + pagination
        $blogs = Blog::on($connection)
            ->with('tags')->where('is_published',true)
            ->orderBy('created_at', 'desc')
            ->paginate(6);

        return response()->json([
            'success' => true,
            'message' => "Blogs fetched",
            'data' => $blogs
        ], 200);

    } catch (\Exception $e) {
        return response()->json([
            'success' => false,
            'message' => "Error",
            'error' => $e->getMessage()
        ], 500);
    }
}
public function searchBlogs(Request $request)
{
    try {
        $connection = "master";
        $query = $request->query('search');

        $blogs = Blog::on($connection)
            ->where('is_published', true)
            ->where(function ($q) use ($query) {
                $q->where('title', 'LIKE', "%{$query}%")
                  ->orWhere('content', 'LIKE', "%{$query}%");
            })
            ->orderByDesc('created_at')
            ->get();

        return response()->json([
            'success' => true,
            'blogs' => $blogs,
            'count' => $blogs->count(),
            'message' => $blogs->isEmpty() ? 'No blogs found for your search.' : null,
        ]);

    } catch (\Exception $e) {
        return response()->json([
            'success' => false,
            'message' => "Error",
            'error' => $e->getMessage()
        ], 500);
    }
}

public function index(Request $request)
{
    try {
        // Inputs
        $start  = (int) $request->get('start', 0);
        $limit  = (int) $request->get('limit', 10);
        $search = $request->get('search');

        // Use correct query builder
        $query = Blog::on("master")->newQuery();

        // $query->where('user_id', $request->auth->id);

        // // Optional: Soft delete filter
        // $query->where('is_deleted', 0);

        // Search
        if ($search) {
            $query->where(function ($q) use ($search) {
                $q->where('title', 'like', "%{$search}%");
            });
        }

    
        // Get total BEFORE skip/take
        $total = $query->count();

        // Apply custom pagination
        $blogs = $query->skip($start)->take($limit)->get();

        return response()->json([
            'success' => true,
            'message' => "Blogs fetched",
            'total' => $total,
            'data' => $blogs
        ]);

    } catch (\Exception $e) {
        return response()->json([
            'success' => false,
            'message' => "Error",
            'error' => $e->getMessage()
        ], 500);
    }
}


public function store(Request $request)
{
    try {
        // ---------------- Validate ----------------
        $validator = Validator::make($request->all(), [
            'title' => 'required|string|max:255',
            'slug' => 'required|string|max:255|regex:/^[a-z0-9-]+$/',
            'content' => 'required',
            'tags' => 'nullable|string',
            'image' => 'nullable',
            'seo_title' => 'nullable|string|max:255',
            'seo_description' => 'nullable|string|max:500',
            'seo_keywords' => 'nullable|string|max:255',
            'is_published' => 'nullable',
            'category' => 'nullable',
            'categorySlug' => 'nullable'
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation failed',
                'errors' => $validator->errors()
            ], 422);
        }

        $validated = $validator->validated();

        $connectionName = "master";

        // ---------------- Manual Unique Slug Check ----------------
        $slug = Str::slug($request->slug);

        $exists = DB::connection($connectionName)
            ->table('blogs')
            ->where('slug', $slug)
            ->exists();

        if ($exists) {
            return response()->json([
                'success' => false,
                'message' => 'Validation failed',
                'errors' => ['slug' => ['The slug has already been taken.']]
            ], 422);
        }

        $validated['slug'] = $slug;
        $validated['is_published'] = $request->boolean('is_published');

   
        // ---------------- Save Blog ----------------
        $blog = new Blog($validated);
        $blog->setConnection($connectionName);
        $blog->user_id = $request->auth->id;
        $blog->save();

        // ---------------- Tags logic ----------------
        if ($request->filled('tags')) {
            $tagNames = array_filter(array_map('trim', explode(',', $request->tags)));
            $tagIds = [];

            foreach ($tagNames as $name) {
                $tag = Tag::on($connectionName)->firstOrCreate(
                    ['name' => $name],
                    ['slug' => Str::slug($name)]
                );
                $tagIds[] = $tag->id;
            }

            $blog->tags()->sync($tagIds);
        }

        return response()->json([
            'success' => true,
            'message' => 'Blog created successfully.',
            'data' => $blog
        ]);

    } catch (\Exception $e) {

        return response()->json([
            'success' => false,
            'message' => 'Error creating blog',
            'error' => $e->getMessage()
        ], 500);
    }
}


public function edit(Request $request,$id)
{
    try {
        // Input
        // Use correct query builder
        $blog = Blog::on("master")->findOrFail($id);
        return response()->json([
            'success' => true,
            'message' => "Blog fetched",
            'data' => $blog
        ]);

    } catch (\Exception $e) {
        return response()->json([
            'success' => false,
            'message' => "Error",
            'error' => $e->getMessage()
        ], 500);
    }
}
public function tags(Request $request, $id)
{
    try {
        // Get blog
        $blog = Blog::on("master")
                    ->with('tags')  // load tags automatically
                    ->find($id);

        if (!$blog) {
            return response()->json([
                'success' => false,
                'message' => "Blog not found",
            ], 404);
        }

        return response()->json([
            'success' => true,
            'message' => "Blog and tags fetched",
            'data' => [
                'blog' => $blog,
            ]
        ]);

    } catch (\Exception $e) {
        return response()->json([
            'success' => false,
            'message' => "Error",
            'error' => $e->getMessage()
        ], 500);
    }
}

  public function update(Request $request,$id)
    {
       $blog=[];
     $validator = Validator::make($request->all(), [
              'title' => 'required|string|max:255',
            'slug' => [
                'required',
                'string',
                'max:255',
                'regex:/^[a-z0-9-]+$/',
            ],
            'content' => 'required',
            'image' => 'nullable|image|mimes:jpeg,png,jpg,gif,webp|max:2048',
            'seo_title' => 'nullable|string|max:255',
            'seo_description' => 'nullable|string|max:500',
            'seo_keywords' => 'nullable|string|max:255',
            'is_published' => 'nullable',
            'category' => 'nullable',
            'categorySlug' => 'nullable',
            'image'=>'nullable'
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation failed',
                'errors' => $validator->errors()
            ], 422);
        }

        $validated = $validator->validated();
        $validated['is_published'] = $request->has('is_published') && $request->is_published === 'on';
        $validated['slug'] = Str::slug($request->slug);

      
        $blog=Blog::on("master")->findOrFail($id);
        $blog->update($validated);

        // Handle tags
        $tagIds = [];
        if ($request->filled('tags')) {
            $tagNames = array_map('trim', explode(',', $request->tags));
            foreach ($tagNames as $name) {
                if ($name !== '') {
                    $tag = Tag::on("master")->firstOrCreate(
                        ['name' => $name],
                        ['slug' => Str::slug($name)]
                    );
                    $tagIds[] = $tag->id;
                }
            }
        }
        $blog->tags()->sync($tagIds);

           return response()->json([
            'success' => true,
            'message' => 'Blog updated successfully.',
        ]);
    }
   public function publicshow(Request $request, $slug)
{
    try {

        // Get blog
        $blog = Blog::on("master")
                    ->with(['tags', 'industry'])->where('slug', $slug)->where('is_published', true)
                    ->firstOrFail();

        // If not published → 404
        if (!$blog->is_published) {
            abort(404);
        }

        // Industries with published blogs
        $industries = Industry::on("master")
                        ->whereHas('blogs', function ($q) {
                            $q->where('is_published', true);
                        })->get();

        // Tags used by published blogs
        $tags = Tag::on("master")
                    ->whereHas('blogs', function ($q) {
                        $q->where('is_published', true);
                    })->get();

        // Recent blogs
        $recentBlogs = Blog::on("master")
                            ->where('is_published', true)
                            ->latest()
                            ->take(5)
                            ->get();

        return response()->json([
            'success' => true,
            'message' => 'Data fetched successfully.',
            'data'    => [
                'blog'        => $blog,
                'industries'  => $industries,
                'tags'        => $tags,
                'recentBlogs' => $recentBlogs
            ]
        ]);

    } catch (\Exception $e) {

        return response()->json([
            'success' => false,
            'message' => 'Error fetching blog data.',
            'error'   => $e->getMessage()
        ], 500);
    }
}
public function destroy(Request $request, $id)
{
    try {
        // dynamic connection
        $connection = "master";

        // fetch blog
        $blog = Blog::on($connection)->find($id);

        if (!$blog) {
            return response()->json([
                'success' => false,
                'message' => "Blog not found",
                'errors' => ["No blog exists with ID {$id}"]
            ], 404);
        }

        // detach tags first (optional but clean)
        $blog->tags()->detach();

        // delete blog
        $blog->delete();

        return response()->json([
            'success' => true,
            'message' => "Blog deleted successfully.",
            'data' => $blog
        ], 200);

    } catch (\Exception $e) {

        return response()->json([
            'success' => false,
            'message' => "Failed to delete blog.",
            'errors' => [$e->getMessage()]
        ], 500);
    }
}
public function restore(Request $request, $id)
{
    $connection = "master";

    try {
        DB::connection($connection)->beginTransaction();

        $blog = Blog::on($connection)
                    ->onlyTrashed()
                    ->where('id', $id)
                    ->first();

        if (!$blog) {
            return response()->json([
                'success' => false,
                'message' => "Blog not found in trash."
            ], 404);
        }

        $blog->restore();

        DB::connection($connection)->commit();

        return response()->json([
            'success' => true,
            'message' => "Blog restored successfully.",
            'data' => Blog::on($connection)->find($id)
        ]);

    } catch (\Exception $e) {

        DB::connection($connection)->rollBack();

        return response()->json([
            'success' => false,
            'message' => "Failed to restore blog.",
            'errors' => [$e->getMessage()]
        ], 500);
    }
}


public function toggleStatus(Request $request, $id)
{
    try {
        // Validate input
        // $request->validate([
        //     'is_published' => 'required|boolean',
        // ]);

        // Dynamic DB connection
        $connection = "master";

        // Find blog
        $blog = Blog::on($connection)->findOrFail($id);

        // Update publish status
        $blog->update([
            'is_published' => $request->is_published,
        ]);

        return response()->json([
            'success' => true,
            'message' => "Blog status updated successfully.",
            'data' => $blog
        ], 200);

    } catch (\Exception $e) {

        return response()->json([
            'success' => false,
            'message' => "Failed to update blog status.",
            'errors' => [$e->getMessage()]
        ], 500);
    }
}

public function blogsByTag(Request $request, $slug)
{
    try {
        $connection = "master";

        $blogs = Blog::on($connection)
            ->where('is_published', true)
            ->whereHas('tags', function ($q) use ($slug) {
                $q->where('name', $slug);
            })
            ->with('tags')
            ->orderBy('created_at', 'desc')
            ->paginate(6);

        return response()->json([
            'success' => true,
            'message' => "Blogs fetched by tag",
            'data' => $blogs
        ]);

    } catch (\Exception $e) {
        return response()->json([
            'success' => false,
            'message' => "Error",
            'error' => $e->getMessage()
        ], 500);
    }
}
public function blogsByIndustry(Request $request, $slug)
{
    Log::info('reached', ['slug' => $slug]);

    // Use slug coming from URL, not query string!
    $slug1 = strtoupper($slug);

    try {
        $connection = "master";

        $blogs = Blog::on($connection)
            ->where('is_published', true)
            ->where('categorySlug', $slug1)
            ->latest()
            ->paginate(9);
    Log::info('reached', ['blogs' => $blogs]);

        return response()->json([
            'success' => true,
            'message' => "Blogs fetched by industry",
            'data' => $blogs
        ]);

    } catch (\Exception $e) {
        return response()->json([
            'success' => false,
            'message' => "Error",
            'error' => $e->getMessage()
        ], 500);
    }
}

public function industry(Request $request)
{
    try {
        // Inputs
     
        // Use correct query builder
        $industry = Industry::on("master")->get();

        return response()->json([
            'success' => true,
            'message' => "Industries fetched",
            'data' => $industry
        ]);

    } catch (\Exception $e) {
        return response()->json([
            'success' => false,
            'message' => "Error",
            'error' => $e->getMessage()
        ], 500);
    }
}

}