namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Models\Setting;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\File;

class SettingsController extends Controller
{
    public function general()
    {
        $settings = Setting::whereIn('key', [
            'site_name',
            'site_description',
            'site_keywords',
            'site_logo',
            'site_favicon',
            'admin_email',
            'timezone',
            'date_format',
            'currency',
            'currency_symbol',
        ])->get()->keyBy('key');

        return view('admin.settings.general', compact('settings'));
    }

    public function updateGeneral(Request $request)
    {
        $request->validate([
            'site_name' => 'required|string|max:255',
            'site_description' => 'nullable|string',
            'site_keywords' => 'nullable|string',
            'admin_email' => 'required|email',
            'timezone' => 'required|string',
            'date_format' => 'required|string',
            'currency' => 'required|string|size:3',
            'currency_symbol' => 'required|string|max:10',
        ]);

        foreach ($request->except('_token') as $key => $value) {
            Setting::updateOrCreate(
                ['key' => $key],
                ['value' => $value, 'type' => 'text', 'group' => 'general']
            );
        }

        // Handle logo upload
        if ($request->hasFile('site_logo')) {
            $request->validate(['site_logo' => 'image|max:2048']);
            $path = $request->file('site_logo')->store('settings', 'public');
            Setting::updateOrCreate(
                ['key' => 'site_logo'],
                ['value' => $path, 'type' => 'file', 'group' => 'general']
            );
        }

        // Handle favicon upload
        if ($request->hasFile('site_favicon')) {
            $request->validate(['site_favicon' => 'image|max:1024']);
            $path = $request->file('site_favicon')->store('settings', 'public');
            Setting::updateOrCreate(
                ['key' => 'site_favicon'],
                ['value' => $path, 'type' => 'file', 'group' => 'general']
            );
        }

        // Log activity
        auth()->guard('admin')->user()->logActivity('Updated general settings');

        return back()->with('success', 'General settings updated successfully.');
    }

    public function seo()
    {
        $settings = Setting::whereIn('key', [
            'meta_title',
            'meta_description',
            'meta_keywords',
            'og_title',
            'og_description',
            'og_image',
            'twitter_card',
            'robots_txt',
            'google_analytics_id',
            'google_verification',
            'facebook_pixel_id',
        ])->get()->keyBy('key');

        return view('admin.settings.seo', compact('settings'));
    }

    public function updateSeo(Request $request)
    {
        $request->validate([
            'meta_title' => 'nullable|string|max:255',
            'meta_description' => 'nullable|string',
            'meta_keywords' => 'nullable|string',
            'og_title' => 'nullable|string|max:255',
            'og_description' => 'nullable|string',
            'twitter_card' => 'nullable|string',
            'google_analytics_id' => 'nullable|string',
            'google_verification' => 'nullable|string',
            'facebook_pixel_id' => 'nullable|string',
        ]);

        foreach ($request->except('_token', 'robots_txt') as $key => $value) {
            Setting::updateOrCreate(
                ['key' => $key],
                ['value' => $value, 'type' => 'text', 'group' => 'seo']
            );
        }

        // Handle robots.txt
        if ($request->has('robots_txt')) {
            File::put(public_path('robots.txt'), $request->robots_txt);
        }

        // Handle OG image
        if ($request->hasFile('og_image')) {
            $request->validate(['og_image' => 'image|max:2048']);
            $path = $request->file('og_image')->store('settings', 'public');
            Setting::updateOrCreate(
                ['key' => 'og_image'],
                ['value' => $path, 'type' => 'file', 'group' => 'seo']
            );
        }

        // Log activity
        auth()->guard('admin')->user()->logActivity('Updated SEO settings');

        return back()->with('success', 'SEO settings updated successfully.');
    }

    public function payment()
    {
        $settings = Setting::whereIn('key', [
            'currency',
            'min_deposit',
            'max_deposit',
            'min_withdrawal',
            'max_withdrawal',
            'withdrawal_fee_percentage',
            'withdrawal_fee_fixed',
            'deposit_bonus_percentage',
            'deposit_bonus_threshold',
            'payment_methods',
        ])->get()->keyBy('key');

        return view('admin.settings.payment', compact('settings'));
    }

    public function updatePayment(Request $request)
    {
    foreach ($request->except('_token') as $key => $value) {
    Setting::updateOrCreate(['key' => $key], ['value' => $value]);
}   
        $request->validate([
            'min_deposit' => 'required|numeric|min:0',
            'max_deposit' => 'required|numeric|min:0',
            'min_withdrawal' => 'required|numeric|min:0',
            'max_withdrawal' => 'required|numeric|min:0',
            'withdrawal_fee_percentage' => 'required|numeric|min:0|max:100',
            'withdrawal_fee_fixed' => 'required|numeric|min:0',
            'deposit_bonus_percentage' => 'required|numeric|min:0|max:100',
            'deposit_bonus_threshold' => 'required|numeric|min:0',
            'payment_methods' => 'required|array',
        ]);

        foreach ($request->except('_token') as $key => $value) {
            Setting::updateOrCreate(
                ['key' => $key],
                ['value' => is_array($value) ? json_encode($value) : $value, 
                 'type' => is_array($value) ? 'json' : 'text', 
                 'group' => 'payment']
            );
        }

        // Log activity
        auth()->guard('admin')->user()->logActivity('Updated payment settings');

        return back()->with('success', 'Payment settings updated successfully.');
    }

    public function maintenance()
    {
        $settings = Setting::whereIn('key', [
            'maintenance_mode',
            'maintenance_message',
            'maintenance_allowed_ips',
        ])->get()->keyBy('key');

        return view('admin.settings.maintenance', compact('settings'));
    }

    public function updateMaintenance(Request $request)
    {
        $request->validate([
            'maintenance_mode' => 'required|boolean',
            'maintenance_message' => 'required_if:maintenance_mode,true|string',
            'maintenance_allowed_ips' => 'nullable|string',
        ]);

        Setting::updateOrCreate(
            ['key' => 'maintenance_mode'],
            ['value' => $request->maintenance_mode, 'type' => 'boolean', 'group' => 'maintenance']
        );

        Setting::updateOrCreate(
            ['key' => 'maintenance_message'],
            ['value' => $request->maintenance_message, 'type' => 'text', 'group' => 'maintenance']
        );

        Setting::updateOrCreate(
            ['key' => 'maintenance_allowed_ips'],
            ['value' => $request->maintenance_allowed_ips, 'type' => 'text', 'group' => 'maintenance']
        );

        // Toggle maintenance mode
        if ($request->maintenance_mode) {
            Artisan::call('down', [
                '--allow' => explode(',', $request->maintenance_allowed_ips ?? '')
            ]);
        } else {
            Artisan::call('up');
        }

        // Log activity
        auth()->guard('admin')->user()->logActivity(
            $request->maintenance_mode ? 'Enabled maintenance mode' : 'Disabled maintenance mode'
        );

        return back()->with('success', 'Maintenance settings updated successfully.');
    }

    public function whatsapp()
    {
        $settings = Setting::whereIn('key', [
            'whatsapp_enabled',
            'whatsapp_number',
            'whatsapp_message',
            'whatsapp_position',
            'whatsapp_animation',
        ])->get()->keyBy('key');

        return view('admin.settings.whatsapp', compact('settings'));
    }

    public function updateWhatsapp(Request $request)
    {
        $request->validate([
            'whatsapp_enabled' => 'required|boolean',
            'whatsapp_number' => 'required_if:whatsapp_enabled,true|string',
            'whatsapp_message' => 'nullable|string',
            'whatsapp_position' => 'required_if:whatsapp_enabled,true|in:left,right',
            'whatsapp_animation' => 'nullable|string',
        ]);

        foreach ($request->except('_token') as $key => $value) {
            Setting::updateOrCreate(
                ['key' => $key],
                ['value' => $value, 'type' => 'text', 'group' => 'whatsapp']
            );
        }

        // Log activity
        auth()->guard('admin')->user()->logActivity('Updated WhatsApp settings');

        return back()->with('success', 'WhatsApp settings updated successfully.');
    }

    public function livechat()
    {
        $settings = Setting::whereIn('key', [
            'livechat_enabled',
            'livechat_provider',
            'livechat_id',
            'livechat_position',
            'livechat_greeting',
        ])->get()->keyBy('key');

        return view('admin.settings.livechat', compact('settings'));
    }

    public function updateLivechat(Request $request)
    {
        $request->validate([
            'livechat_enabled' => 'required|boolean',
            'livechat_provider' => 'required_if:livechat_enabled,true|in:tawkto,
            
    public function updateLivechat(Request $request)
    {
        $request->validate([
            'livechat_enabled' => 'required|boolean',
            'livechat_provider' => 'required_if:livechat_enabled,true|in:tawkto,crisp,chatra,whatsapp',
            'livechat_id' => 'required_if:livechat_enabled,true|string',
            'livechat_position' => 'required_if:livechat_enabled,true|in:left,right',
            'livechat_greeting' => 'nullable|string|max:255',
        ]);

        foreach ($request->except('_token') as $key => $value) {
            Setting::updateOrCreate(
                ['key' => $key],
                ['value' => $value, 'type' => 'text', 'group' => 'livechat']
            );
        }

        // Log activity
        auth()->guard('admin')->user()->logActivity('Updated live chat settings');

        return back()->with('success', 'Live chat settings updated successfully.');
    }

    public function email()
    {
        $settings = Setting::whereIn('key', [
            'mail_driver',
            'mail_host',
            'mail_port',
            'mail_username',
            'mail_password',
            'mail_encryption',
            'mail_from_address',
            'mail_from_name',
        ])->get()->keyBy('key');

        return view('admin.settings.email', compact('settings'));
    }

    public function updateEmail(Request $request)
    {
        $request->validate([
            'mail_driver' => 'required|in:smtp,sendmail,mailgun,ses,postmark,log,array',
            'mail_host' => 'required_if:mail_driver,smtp|nullable|string',
            'mail_port' => 'required_if:mail_driver,smtp|nullable|integer',
            'mail_username' => 'nullable|string',
            'mail_password' => 'nullable|string',
            'mail_encryption' => 'nullable|in:tls,ssl,null',
            'mail_from_address' => 'required|email',
            'mail_from_name' => 'required|string|max:255',
        ]);

        foreach ($request->except('_token') as $key => $value) {
            Setting::updateOrCreate(
                ['key' => $key],
                ['value' => $value, 'type' => 'text', 'group' => 'email']
            );
        }

        // Update .env file
        $this->updateEnvFile([
            'MAIL_MAILER' => $request->mail_driver,
            'MAIL_HOST' => $request->mail_host,
            'MAIL_PORT' => $request->mail_port,
            'MAIL_USERNAME' => $request->mail_username,
            'MAIL_PASSWORD' => $request->mail_password,
            'MAIL_ENCRYPTION' => $request->mail_encryption,
            'MAIL_FROM_ADDRESS' => $request->mail_from_address,
            'MAIL_FROM_NAME' => '"' . $request->mail_from_name . '"',
        ]);

        // Log activity
        auth()->guard('admin')->user()->logActivity('Updated email settings');

        return back()->with('success', 'Email settings updated successfully.');
    }

    protected function updateEnvFile($data)
    {
        $envFile = base_path('.env');
        $content = file_get_contents($envFile);

        foreach ($data as $key => $value) {
            if ($value !== null) {
                if (strpos($content, $key . '=') !== false) {
                    $content = preg_replace(
                        '/' . $key . '=.*/',
                        $key . '=' . $value,
                        $content
                    );
                } else {
                    $content .= "\n" . $key . '=' . $value;
                }
            }
        }

        file_put_contents($envFile, $content);
    }

    public function testEmail(Request $request)
    {
        $request->validate([
            'test_email' => 'required|email',
        ]);

        try {
            \Mail::raw('This is a test email from your RGSMM application.', function ($message) use ($request) {
                $message->to($request->test_email)
                    ->subject('Test Email from RGSMM');
            });

            return back()->with('success', 'Test email sent successfully to ' . $request->test_email);
        } catch (\Exception $e) {
            return back()->with('error', 'Failed to send test email: ' . $e->getMessage());
        }
    }
}