<?php

namespace App\Http\Controllers\Refactor\Admin;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\Model\WarmupStrategy;
use App\Services\WarmupStrategyService;
use App\Dto\WarmupStrategyData;

class WarmupStrategyController extends Controller
{
    protected $service;

    public function __construct(WarmupStrategyService $service)
    {
        $this->service = $service;
    }

    public function index(Request $request)
    {
        if (!$request->user()->admin->can('read', new WarmupStrategy())) {
            return $this->notAuthorized();
        }

        $stats = [
            'total' => WarmupStrategy::count(),
            'active' => WarmupStrategy::where('status', WarmupStrategy::STATUS_ACTIVE)->count(),
        ];

        return view('refactor.pages.admin.warmup-strategies.index', compact('stats'));
    }

    public function listing(Request $request)
    {
        if (!$request->user()->admin->can('read', new WarmupStrategy())) {
            return $this->notAuthorized();
        }

        $query = $this->service->listQuery($request->keyword);

        if ($request->status && $request->status !== 'all') {
            $query = $query->where('status', $request->status);
        }

        $items = $query->orderBy('created_at', 'desc')->paginate($request->per_page ?? 25);

        $previews = [];
        foreach ($items as $item) {
            $previews[$item->id] = $this->service->buildPreview($item);
        }

        return view('refactor.pages.admin.warmup-strategies._list', compact('items', 'previews'));
    }

    public function create(Request $request)
    {
        if (!$request->user()->admin->can('read', new WarmupStrategy())) {
            return $this->notAuthorized();
        }

        $strategy = $this->service->newStrategy(WarmupStrategy::PRESET_BALANCED);
        $preview = $this->service->buildPreview($strategy);
        $presetPayloads = [
            WarmupStrategy::PRESET_BALANCED => $this->service->presetPayload(WarmupStrategy::PRESET_BALANCED),
            WarmupStrategy::PRESET_CAUTIOUS => $this->service->presetPayload(WarmupStrategy::PRESET_CAUTIOUS),
            WarmupStrategy::PRESET_AGGRESSIVE => $this->service->presetPayload(WarmupStrategy::PRESET_AGGRESSIVE),
        ];

        return view('refactor.pages.admin.warmup-strategies.create', compact('strategy', 'preview', 'presetPayloads'));
    }

    public function store(Request $request)
    {
        if (!$request->user()->admin->can('read', new WarmupStrategy())) {
            return response()->json(['status' => 'error', 'message' => 'Not authorized'], 403);
        }

        $rules = [
            'name' => 'required|string|max:255',
            'description' => 'required|string',
            'preset' => 'required',
            'growth_strategy' => 'required',
            'starting_volume' => 'required|integer|min:1',
            'quota_type' => 'required',
            'limit_type' => 'required',
            'send_on_weekends' => 'required',
            'enable_safety_checks' => 'required',
            'pause_on_negative_signals' => 'required',
            'max_bounce_rate' => 'required|numeric|min:0|max:100',
            'max_complaint_rate' => 'required|numeric|min:0|max:100',
        ];

        $validator = \Validator::make($request->all(), $rules);

        if ($validator->fails()) {
            return response()->json(['status' => 'error', 'errors' => $validator->errors()], 422);
        }

        try {
            $dto = WarmupStrategyData::fromRequest($request);
            $this->service->create($dto);

            return response()->json([
                'status' => 'success',
                'message' => trans('refactor/admin_warmup_strategies.flash.created'),
            ]);
        } catch (\Exception $e) {
            return response()->json(['status' => 'error', 'message' => $e->getMessage()], 500);
        }
    }

    public function edit(Request $request, $uid)
    {
        $strategy = WarmupStrategy::findByUid($uid);

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

        if (!$request->user()->admin->can('update', $strategy)) {
            return $this->notAuthorized();
        }

        $preview = $this->service->buildPreview($strategy);
        $presetPayloads = [
            WarmupStrategy::PRESET_BALANCED => $this->service->presetPayload(WarmupStrategy::PRESET_BALANCED),
            WarmupStrategy::PRESET_CAUTIOUS => $this->service->presetPayload(WarmupStrategy::PRESET_CAUTIOUS),
            WarmupStrategy::PRESET_AGGRESSIVE => $this->service->presetPayload(WarmupStrategy::PRESET_AGGRESSIVE),
        ];

        return view('refactor.pages.admin.warmup-strategies.edit', compact('strategy', 'preview', 'presetPayloads'));
    }

    public function update(Request $request, $uid)
    {
        $strategy = WarmupStrategy::findByUid($uid);

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

        if (!$request->user()->admin->can('update', $strategy)) {
            return response()->json(['status' => 'error', 'message' => 'Not authorized'], 403);
        }

        $rules = [
            'name' => 'required|string|max:255',
            'description' => 'required|string',
            'preset' => 'required',
            'growth_strategy' => 'required',
            'starting_volume' => 'required|integer|min:1',
            'quota_type' => 'required',
            'limit_type' => 'required',
            'send_on_weekends' => 'required',
            'enable_safety_checks' => 'required',
            'pause_on_negative_signals' => 'required',
            'max_bounce_rate' => 'required|numeric|min:0|max:100',
            'max_complaint_rate' => 'required|numeric|min:0|max:100',
        ];

        $validator = \Validator::make($request->all(), $rules);

        if ($validator->fails()) {
            return response()->json(['status' => 'error', 'errors' => $validator->errors()], 422);
        }

        try {
            $dto = WarmupStrategyData::fromRequest($request);
            $this->service->update($strategy, $dto);

            return response()->json([
                'status' => 'success',
                'message' => trans('refactor/admin_warmup_strategies.flash.updated'),
            ]);
        } catch (\Exception $e) {
            return response()->json(['status' => 'error', 'message' => $e->getMessage()], 500);
        }
    }

    public function enable(Request $request)
    {
        $uids = is_array($request->uids) ? $request->uids : explode(',', $request->uids);
        $strategies = WarmupStrategy::whereIn('uid', $uids)->get();
        $this->service->enableMany($strategies, $request->user());

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

    public function disable(Request $request)
    {
        $uids = is_array($request->uids) ? $request->uids : explode(',', $request->uids);
        $strategies = WarmupStrategy::whereIn('uid', $uids)->get();
        $this->service->disableMany($strategies, $request->user());

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

    public function delete(Request $request)
    {
        $uids = is_array($request->uids) ? $request->uids : explode(',', $request->uids);
        $strategies = WarmupStrategy::whereIn('uid', $uids)->get();
        $this->service->deleteMany($strategies, $request->user());

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

    public function preview(Request $request)
    {
        try {
            $dto = WarmupStrategyData::fromRequest($request);
            $preview = $this->service->buildPreview($dto);

            return response()->json([
                'status' => 'success',
                'preview' => $preview->toArray(),
            ]);
        } catch (\Exception $e) {
            return response()->json(['status' => 'error', 'message' => $e->getMessage()], 400);
        }
    }
}