<?php

namespace App\Http\Controllers;

use App\Models\Blog;
use Facebook\Facebook;
use App\Models\Comment;
use Cloudinary\Cloudinary;
use Illuminate\Support\Str;
use App\Models\BlogCategory;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use App\Http\Controllers\Controller;
use Cloudinary\Transformation\Resize;
use Abraham\TwitterOAuth\TwitterOAuth;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Validator;

class BlogController extends Controller
{

    public function __construct()
    {
        $this->middleware(['auth', 'verified', 'agent'])->except('show', 'list', 'allBlog', 'allCategory', 'storeCat');
    }
    public function index()
    {
        $blogs = Blog::all();
        return view('settings.blog.index', compact("blogs"));
    }
    // for api
    public function allBlog()
    {
        return response()->json([
            'status' => 'success',
            "data" => Blog::latest()->limit(20)->get(),
        ], 200);
    }
    public function allCategory()
    {
        return response()->json([
            'status' => 'success',
            "data" => BlogCategory::latest()->limit(20)->get(),
        ], 200);
    }

    public function storeCat(Request $request)
    {

        try {
            $validatedData = $request->validate([
                'name' => 'required|string',
            ]);
            $category = new BlogCategory();
            $category->name = $validatedData['name'];
            $category->slug = Str::slug($validatedData['name'], '-');
            $category->save();
            return response()->json(['status' => 'success', 'message' => 'Blog Category post Saved'], 200);
        } catch (\Throwable $th) {
            return response()->json(['status' => 'error', 'message' => $th->getMessage()]);
        }
    }


    public function create()
    {
        $categories = BlogCategory::latest()->get();
        return view('settings.blog.create', compact('categories'));
    }

    public function comment()
    {
        return view('settings.blog.create');
    }

    public function category()
    {
        $categories = BlogCategory::all();
        return view('settings.blog.category', compact('categories'));
    }

    public function list()
    {
        $blogs = Blog::latest()->paginate(10);
        $oldest = Blog::select('title', 'image', 'created_at', 'slug')->inRandomOrder()->limit(2)->get();
        return view('settings.blog.list', compact("blogs", "oldest"));
    }


    public function storeCategory(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|string',
        ]);

        if ($validator->fails()) {
            return redirect()->back()->with('error', $validator->errors()->first());
        }

        try {
            $category = new BlogCategory();
            $category->name = $request->get('name');
            $category->slug = Str::slug($request['name'], '-');

            $category->save();
            return redirect()->back()->with('status', 'Blog Category post Saved');
        } catch (\Throwable $th) {
            return redirect()->back()->with('error', $th->getMessage());
        }
    }

    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|string',
            'description' => 'required',
            'tag' => 'nullable|string',
            'category_id' => 'required|string',
            'image' => 'required|image',
            'keywords' => 'nullable|string',
            'meta_description' => 'nullable|string',
            'author' => 'nullable|string',
            'publish_date' => 'nullable|date',
            'read_time' => 'nullable|integer',
            'featured' => 'nullable|boolean',
        ]);

        if ($validator->fails()) {
            return redirect()->back()->with('error', $validator->errors()->first());
        }

        try {
            $blog = new Blog();
            $blog->title = $request->get('title');
            $blog->slug = Str::slug($request['title'], '-');
            $blog->description = $request->get('description');
            $blog->tag = $request->get('tag');
            $blog->category_id = $request->get('category_id');
            $blog->keywords = $request->get('keywords');
            $blog->meta_description = $request->get('meta_description');
            $blog->author = $request->get('author') ?? 'Admin';
            $blog->publish_date = $request->get('publish_date') ?? now();
            $blog->read_time = $request->get('read_time') ?? 5; // Default read time
            $blog->featured = $request->get('featured') ?? false;

            if ($request->hasFile('image')) {
                // Upload image to Cloudinary
                $cloudinary = new Cloudinary();
                $uploadResult = $cloudinary->uploadApi()->upload(
                    $request->file('image')->getRealPath(),
                    ['folder' => 'blogImages']
                );
                $blog->image = $uploadResult['secure_url'];

                $resizedImageUrl = $cloudinary->image($uploadResult['public_id'])
                    ->resize(Resize::fill(1200, 630)) // Resize to Open Graph recommended size
                    ->toUrl();
                $blog->resize_image = $resizedImageUrl;
            }

            $blog->save();
            // Share post on social platforms
            // $this->shareOnFacebook($blog);
            // $this->shareOnTwitter($blog);
            return redirect()->back()->with('status', 'Blog post saved successfully');
        } catch (\Throwable $th) {
            return redirect()->back()->with('error', $th->getMessage());
        }
    }


    // Function to share on Facebook
    protected function shareOnFacebook($blog)
    {
        $fb = new Facebook(config: [
            'app_id' => env('FACEBOOK_APP_ID'),
            'app_secret' => env('FACEBOOK_APP_SECRET'),
            'default_graph_version' => 'v11.0',
        ]);

        try {
            $fb->post('/me/feed', [
                'message' => $blog->title,
                'link' => route('blog.show', $blog->slug),
            ], env('FACEBOOK_PAGE_ACCESS_TOKEN'));
        } catch (\Facebook\Exceptions\FacebookResponseException $e) {
            Log::error("Facebook Graph returned an error: " . $e->getMessage());
        } catch (\Facebook\Exceptions\FacebookSDKException $e) {
            Log::error("Facebook SDK returned an error: " . $e->getMessage());
        }
    }

    // Function to share on Twitter
    protected function shareOnTwitter($blog)
    {
        $twitter = new TwitterOAuth(
            env('TWITTER_API_KEY'),
            env('TWITTER_API_SECRET'),
            env('TWITTER_ACCESS_TOKEN'),
            env('TWITTER_ACCESS_TOKEN_SECRET')
        );

        $twitter->post('statuses/update', [
            'status' => $blog->title . ' ' . route('blog.show', $blog->slug)
        ]);

        if ($twitter->getLastHttpCode() != 200) {
            Log::error("Error posting to Twitter.");
        }
    }
    public function show(Blog $blog)
    {
        $comments = Comment::where('blog_id', '=', $blog->id)->get();
        $oldest = Blog::select('title', 'image', 'created_at', 'slug')->inRandomOrder()->limit(2)->get();
        return view('settings.blog.show', compact('blog', 'oldest', 'comments'));
    }

    public function edit(Blog $blog)
    {
        //
    }

    public function update(Request $request, Blog $blog)
    {
        try {
            $blog->title = $request->get('title');
            $blog->slug = Str::slug($request['title'], '-');
            $blog->description = $request->get('description');
            $blog->tag = $request->get('tag');
            $blog->category = $request->get('category');

            // Check if there's an image file in the request
            if ($request->hasFile('image')) {
                if ($blog->image) {
                    Storage::disk('public')->delete(str_replace('/storage/', '', $blog->image));
                }
                $blog->image = '/storage/' . $request->file('image')->store('blogImages', 'public');
            }

            $blog->save();
            return redirect()->back()->with('status', 'Blog post updated successfully.');
        } catch (\Throwable $th) {
            return redirect()->back()->with('error', $th->getMessage());
        }
    }


    public function updateCategory(Request $request)
    {
        // Validate that both 'id' and 'name' fields are provided
        $request->validate([
            'id' => 'required|exists:blog_categories,id',
            'name' => 'required|string|max:255',
        ]);

        try {
            // Find the category by ID
            $category = BlogCategory::find($request->id);

            if ($category) {
                // Update the category's name and slug
                $category->name = $request->get('name');
                $category->slug = Str::slug($request->get('name'), '-');

                // Save the updated category
                $category->save();

                return redirect()->back()->with('status', 'Blog category updated successfully.');
            } else {
                return redirect()->back()->with('error', 'Category not found.');
            }
        } catch (\Throwable $th) {
            // Handle exceptions and provide feedback to the user
            return redirect()->back()->with('error', 'Error updating category: ' . $th->getMessage());
        }
    }


    public function destroy(Blog $blog)
    {
        $blog->delete();
        return redirect()->back()->with('status', 'Blog post deleted');
    }
    public function destroyCategory(Request $request, $slug)
    {
        try {
            // Attempt to find the category by slug
            $category = BlogCategory::where('slug', $slug)->firstOrFail();

            // Delete the category
            $category->delete();

            return redirect()->back()->with('status', 'Blog category deleted successfully.');
        } catch (\Throwable $th) {
            // Handle exceptions and provide feedback to the user
            return redirect()->back()->with('error', 'Error deleting category: ' . $th->getMessage());
        }
    }
}