<?php

namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Models\Article;
use Carbon\Carbon;
use Illuminate\Support\Facades\Auth;
use Inertia\Inertia;

class DashboardController extends Controller
{
    public function index()
    {
        $user = Auth::user();

        // Calculate article metrics
        $articleMetrics = $this->getArticleMetrics($user);

        // Get recent articles
        $recentArticles = $this->getRecentArticles($user);

        // Get statistics data
        $statisticsData = $this->getStatisticsData($user);

        return Inertia::render('admin/Dashboard', [
            'articleMetrics' => $articleMetrics,
            'recentArticles' => $recentArticles,
            'statisticsData' => $statisticsData,
        ]);
    }

    private function getArticleMetrics($user)
    {
        // Base query for articles (excluding soft deleted)
        $baseQuery = Article::query();

        // Check if user has limited permissions (owner only)
        $hasOwnerOnlyPermissions = false;
        if ((! $user->can('articles.mattock.view') && $user->can('articles.mattock.owner.view')) ||
            (! $user->can('articles.pipopa.view') && $user->can('articles.pipopa.owner.view'))) {
            $hasOwnerOnlyPermissions = true;
        }

        if ($hasOwnerOnlyPermissions) {
            $baseQuery->where('user_id', $user->id);
        }

        // Calculate metrics
        $totalArticles = (clone $baseQuery)->count();
        $publishedArticles = (clone $baseQuery)->where('status', 'publish')->count();
        $pendingArticles = (clone $baseQuery)->where('status', 'pending')->count();
        $draftArticles = (clone $baseQuery)->where('status', 'draft')->count();

        // Calculate last month metrics for trends (simplified)
        $lastMonthTotal = (clone $baseQuery)->whereMonth('created_at', now()->subMonth()->month)->count();
        $lastMonthPublished = (clone $baseQuery)->where('status', 'publish')->whereMonth('created_at', now()->subMonth()->month)->count();
        $lastMonthPending = (clone $baseQuery)->where('status', 'pending')->whereMonth('created_at', now()->subMonth()->month)->count();
        $lastMonthDraft = (clone $baseQuery)->where('status', 'draft')->whereMonth('created_at', now()->subMonth()->month)->count();

        // Calculate trend percentages
        $totalTrend = $this->calculateTrend($totalArticles, $lastMonthTotal);
        $publishedTrend = $this->calculateTrend($publishedArticles, $lastMonthPublished);
        $pendingTrend = $this->calculateTrend($pendingArticles, $lastMonthPending);
        $draftTrend = $this->calculateTrend($draftArticles, $lastMonthDraft);

        return [
            [
                'id'        => 'total-articles',
                'label'     => 'Total Articles',
                'value'     => number_format($totalArticles),
                'icon'      => 'file-text',
                'iconBg'    => 'bg-blue-100 dark:bg-blue-900/20',
                'iconColor' => 'text-blue-600 dark:text-blue-400',
                'trend'     => $totalTrend,
                'period'    => 'from last month',
            ],
            [
                'id'        => 'published-articles',
                'label'     => 'Published',
                'value'     => number_format($publishedArticles),
                'icon'      => 'check-circle',
                'iconBg'    => 'bg-orange-100 dark:bg-orange-900/20',
                'iconColor' => 'text-orange-600 dark:text-orange-400',
                'trend'     => $publishedTrend,
                'period'    => 'from last month',
            ],
            [
                'id'        => 'pending-articles',
                'label'     => 'Pending',
                'value'     => number_format($pendingArticles),
                'icon'      => 'clock',
                'iconBg'    => 'bg-yellow-100 dark:bg-yellow-900/20',
                'iconColor' => 'text-yellow-600 dark:text-yellow-400',
                'trend'     => $pendingTrend,
                'period'    => 'from last month',
            ],
            [
                'id'        => 'draft-articles',
                'label'     => 'Draft',
                'value'     => number_format($draftArticles),
                'icon'      => 'edit',
                'iconBg'    => 'bg-gray-100 dark:bg-gray-900/20',
                'iconColor' => 'text-gray-600 dark:text-gray-400',
                'trend'     => $draftTrend,
                'period'    => 'from last month',
            ],
        ];
    }

    private function calculateTrend($current, $previous)
    {
        if ($previous == 0) {
            return [
                'type'  => $current > 0 ? 'up' : 'down',
                'value' => $current > 0 ? 100 : 0,
            ];
        }

        $percentChange = (($current - $previous) / $previous) * 100;

        return [
            'type'  => $percentChange >= 0 ? 'up' : 'down',
            'value' => abs(round($percentChange, 2)),
        ];
    }

    private function getRecentArticles($user)
    {
        $query = Article::with(['user', 'primaryCategory']);

        // Check permissions và xác định loại articles user có thể xem
        $allowedTypes = [];
        $ownerOnlyTypes = [];

        // Check Mattock permissions (type = 0)
        if ($user->can('articles.mattock.view')) {
            $allowedTypes[] = 0; // Có thể xem tất cả mattock articles
        } elseif ($user->can('articles.mattock.owner.view')) {
            $ownerOnlyTypes[] = 0; // Chỉ xem mattock articles của mình
        }

        // Check Pipopa permissions (type = 1)
        if ($user->can('articles.pipopa.view')) {
            $allowedTypes[] = 1; // Có thể xem tất cả pipopa articles
        } elseif ($user->can('articles.pipopa.owner.view')) {
            $ownerOnlyTypes[] = 1; // Chỉ xem pipopa articles của mình
        }

        // Xây dựng query dựa trên permissions
        if (empty($allowedTypes) && empty($ownerOnlyTypes)) {
            // Không có quyền xem gì cả
            return [];
        }

        $query->where(function ($q) use ($allowedTypes, $ownerOnlyTypes, $user) {
            // Add articles user can view all
            if (! empty($allowedTypes)) {
                $q->whereIn('type', $allowedTypes);
            }

            // Add articles user can only view their own
            if (! empty($ownerOnlyTypes)) {
                $ownerQuery = function ($subQ) use ($ownerOnlyTypes, $user) {
                    $subQ->whereIn('type', $ownerOnlyTypes)
                        ->where('user_id', $user->id);
                };

                if (! empty($allowedTypes)) {
                    $q->orWhere($ownerQuery);
                } else {
                    $q->where($ownerQuery);
                }
            }
        });

        // Get 10 most recent articles
        $articles = $query->orderBy('updated_at', 'desc')
            ->take(10)
            ->get();

        return $articles->map(function ($article) {
            return [
                'id'         => $article->id,
                'title'      => $article->title,
                'type'       => $article->type === 0 ? 'Mattock' : 'Pipopa',
                'status'     => $article->status,
                'author'     => $article->user->name ?? 'Unknown',
                'category'   => $article->primaryCategory->name ?? '--',
                'updated_at' => $article->updated_at->format('M d, Y H:i'),
                'edit_url'   => $article->type === 0
                    ? route('admin.mattock.articles.edit', $article->id)
                    : route('admin.pipopa.articles.edit', $article->id),
            ];
        });
    }

    private function getStatisticsData($user)
    {
        // Check permissions
        $canViewMattock = $user->can('articles.mattock.view');
        $canViewMattockOwner = $user->can('articles.mattock.owner.view');
        $canViewPipopa = $user->can('articles.pipopa.view');
        $canViewPipopaOwner = $user->can('articles.pipopa.owner.view');

        $now = Carbon::now();
        $startOfYear = $now->copy()->startOfYear();

        // Generate monthly data for current year
        $monthlyData = $this->generateMonthlyData($user, $startOfYear, $now, $canViewMattock, $canViewMattockOwner, $canViewPipopa, $canViewPipopaOwner);

        // Generate quarterly data for current year
        $quarterlyData = $this->generateQuarterlyData($user, $startOfYear, $now, $canViewMattock, $canViewMattockOwner, $canViewPipopa, $canViewPipopaOwner);

        // Generate yearly data for last 5 years
        $yearlyData = $this->generateYearlyData($user, $now, $canViewMattock, $canViewMattockOwner, $canViewPipopa, $canViewPipopaOwner);

        return [
            'monthly'   => $monthlyData,
            'quarterly' => $quarterlyData,
            'annually'  => $yearlyData,
        ];
    }

    private function generateMonthlyData($user, $startOfYear, $now, $canViewMattock, $canViewMattockOwner, $canViewPipopa, $canViewPipopaOwner)
    {
        $months = [];
        $mattockData = [];
        $pipopaData = [];

        // Generate month labels and data
        for ($i = 0; $i < 12; $i++) {
            $monthStart = $startOfYear->copy()->addMonths($i);
            $monthEnd = $monthStart->copy()->endOfMonth();

            $months[] = $monthStart->format('M');

            // Get Mattock articles count for this month
            $mattockCount = 0;
            if ($canViewMattock || $canViewMattockOwner) {
                $query = Article::where('type', 0)
                    ->whereBetween('created_at', [$monthStart, $monthEnd]);

                if (! $canViewMattock && $canViewMattockOwner) {
                    $query->where('user_id', $user->id);
                }

                $mattockCount = $query->count();
            }

            // Get Pipopa articles count for this month
            $pipopaCount = 0;
            if ($canViewPipopa || $canViewPipopaOwner) {
                $query = Article::where('type', 1)
                    ->whereBetween('created_at', [$monthStart, $monthEnd]);

                if (! $canViewPipopa && $canViewPipopaOwner) {
                    $query->where('user_id', $user->id);
                }

                $pipopaCount = $query->count();
            }

            $mattockData[] = $mattockCount;
            $pipopaData[] = $pipopaCount;
        }

        $series = [];

        if ($canViewMattock || $canViewMattockOwner) {
            $series[] = [
                'name' => 'Mattock Articles',
                'data' => $mattockData,
            ];
        }

        if ($canViewPipopa || $canViewPipopaOwner) {
            $series[] = [
                'name' => 'Pipopa Articles',
                'data' => $pipopaData,
            ];
        }

        // Add total line if user has both permissions
        if (($canViewMattock || $canViewMattockOwner) && ($canViewPipopa || $canViewPipopaOwner)) {
            $totalData = array_map(function ($mattock, $pipopa) {
                return $mattock + $pipopa;
            }, $mattockData, $pipopaData);

            $series[] = [
                'name' => 'Total Articles',
                'data' => $totalData,
            ];
        }

        return [
            'categories' => $months,
            'series'     => $series,
        ];
    }

    private function generateQuarterlyData($user, $startOfYear, $now, $canViewMattock, $canViewMattockOwner, $canViewPipopa, $canViewPipopaOwner)
    {
        $quarters = ['Q1', 'Q2', 'Q3', 'Q4'];
        $mattockData = [];
        $pipopaData = [];

        for ($i = 0; $i < 4; $i++) {
            $quarterStart = $startOfYear->copy()->addMonths($i * 3);
            $quarterEnd = $quarterStart->copy()->addMonths(3)->subDay();

            // Get Mattock articles count for this quarter
            $mattockCount = 0;
            if ($canViewMattock || $canViewMattockOwner) {
                $query = Article::where('type', 0)
                    ->whereBetween('created_at', [$quarterStart, $quarterEnd]);

                if (! $canViewMattock && $canViewMattockOwner) {
                    $query->where('user_id', $user->id);
                }

                $mattockCount = $query->count();
            }

            // Get Pipopa articles count for this quarter
            $pipopaCount = 0;
            if ($canViewPipopa || $canViewPipopaOwner) {
                $query = Article::where('type', 1)
                    ->whereBetween('created_at', [$quarterStart, $quarterEnd]);

                if (! $canViewPipopa && $canViewPipopaOwner) {
                    $query->where('user_id', $user->id);
                }

                $pipopaCount = $query->count();
            }

            $mattockData[] = $mattockCount;
            $pipopaData[] = $pipopaCount;
        }

        $series = [];

        if ($canViewMattock || $canViewMattockOwner) {
            $series[] = [
                'name' => 'Mattock Articles',
                'data' => $mattockData,
            ];
        }

        if ($canViewPipopa || $canViewPipopaOwner) {
            $series[] = [
                'name' => 'Pipopa Articles',
                'data' => $pipopaData,
            ];
        }

        // Add total line if user has both permissions
        if (($canViewMattock || $canViewMattockOwner) && ($canViewPipopa || $canViewPipopaOwner)) {
            $totalData = array_map(function ($mattock, $pipopa) {
                return $mattock + $pipopa;
            }, $mattockData, $pipopaData);

            $series[] = [
                'name' => 'Total Articles',
                'data' => $totalData,
            ];
        }

        return [
            'categories' => $quarters,
            'series'     => $series,
        ];
    }

    private function generateYearlyData($user, $now, $canViewMattock, $canViewMattockOwner, $canViewPipopa, $canViewPipopaOwner)
    {
        $years = [];
        $mattockData = [];
        $pipopaData = [];

        // Get data for last 5 years
        for ($i = 4; $i >= 0; $i--) {
            $year = $now->copy()->subYears($i);
            $yearStart = $year->copy()->startOfYear();
            $yearEnd = $year->copy()->endOfYear();

            $years[] = $year->format('Y');

            // Get Mattock articles count for this year
            $mattockCount = 0;
            if ($canViewMattock || $canViewMattockOwner) {
                $query = Article::where('type', 0)
                    ->whereBetween('created_at', [$yearStart, $yearEnd]);

                if (! $canViewMattock && $canViewMattockOwner) {
                    $query->where('user_id', $user->id);
                }

                $mattockCount = $query->count();
            }

            // Get Pipopa articles count for this year
            $pipopaCount = 0;
            if ($canViewPipopa || $canViewPipopaOwner) {
                $query = Article::where('type', 1)
                    ->whereBetween('created_at', [$yearStart, $yearEnd]);

                if (! $canViewPipopa && $canViewPipopaOwner) {
                    $query->where('user_id', $user->id);
                }

                $pipopaCount = $query->count();
            }

            $mattockData[] = $mattockCount;
            $pipopaData[] = $pipopaCount;
        }

        $series = [];

        if ($canViewMattock || $canViewMattockOwner) {
            $series[] = [
                'name' => 'Mattock Articles',
                'data' => $mattockData,
            ];
        }

        if ($canViewPipopa || $canViewPipopaOwner) {
            $series[] = [
                'name' => 'Pipopa Articles',
                'data' => $pipopaData,
            ];
        }

        // Add total line if user has both permissions
        if (($canViewMattock || $canViewMattockOwner) && ($canViewPipopa || $canViewPipopaOwner)) {
            $totalData = array_map(function ($mattock, $pipopa) {
                return $mattock + $pipopa;
            }, $mattockData, $pipopaData);

            $series[] = [
                'name' => 'Total Articles',
                'data' => $totalData,
            ];
        }

        return [
            'categories' => $years,
            'series'     => $series,
        ];
    }
}