<?php

namespace App\Http\Controllers;

use App\Helper\Helper;
use GuzzleHttp\Exception\RequestException;
use Illuminate\Http\Request;
use Illuminate\Support\MessageBag;
use Session;
use App\Model\Master\ProspectInitialData;
use App\Model\Master\EmailVerification;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Auth;
use App\Model\User;
use Illuminate\Support\Facades\Mail;
use App\Mail\WelcomeGoogleLoginMail;
use App\Http\Helper\JwtToken;
use Carbon\Carbon;
use Illuminate\Support\Str;
use App\Model\Master\AsteriskServer;
use App\Model\Master\UserExtension;
use Illuminate\Support\Facades\Http;


class GoogleController extends Controller
{
   private $request;

    public function __construct(Request $request)
    {
        $this->request = $request;
    }


public function handleGoogleCallback(Request $request)
{
    Log::info('Reached Google Callback', ['google_id' => $request->id]);

    try {
        $googleId = $request->get('id');
        $email = $request->get('email');
        $name = $request->get('name');

        if (!$googleId || !$email) {
            return response()->json(['error' => 'Invalid Google data'], 400);
        }

        // Try to find user by google_id
        $user = User::where('google_id', $googleId)->where('email', $email)->where('is_deleted', 0)->first();
        Log::info('Reached Google user', ['user' => $user]);

        if (!$user) {
            // If not found, try to match by email
            $user = User::where('email', $email)->where('is_deleted', 0)->first();

            if (!$user) {
                Log::warning('User not found during Google login', ['email' => $email]);
                $prospectInitialData = new ProspectInitialData();
                $prospectInitialData->email        = $email;
                $prospectInitialData->name         = $name ?? '';
                $firstName = explode(" ", $name)[0];
                $prospectInitialData->company_name = $firstName . "'s Company";
                $prospectInitialData->country_code = '';
                $prospectInitialData->phone_number = '';
                $prospectInitialData->password     = null;
                // $prospectInitialData->google_id    = $googleId;
                $prospectInitialData->save();

                // Create verification record
                $verificationCode = '123456'; // rand(100000, 999999);
                $verification = EmailVerification::create([
                    'id'     => (string) Str::uuid(),
                    'email'  => $prospectInitialData->email,
                    'code'   => $verificationCode,
                    'expiry' => Carbon::now()->addMinutes(15),
                    'status' => '3', // pending
                ]);

                // 🔑 Auto verify because Google email is trusted
                $verification->status = 4; // verified
                $verification->save();

                return response()->json([
                    "success"  => true,
                    "message"  => "Prospect saved & email auto-verified via Google",
                    "prospect" => $prospectInitialData,
                    "email_otp_id" => $verification->id,
                    "google_id" => $googleId,
                    "email" => $email,
                ], 201);
            }

            // Link Google ID to existing user
            $user->google_id = $googleId;
            $user->save();
        }
            $webphone = $user->webphone; // default value from DB

            if ($user->webphone == 1) {
                $updated = User::where('id', $user->id)->update(['webphone' => false]);
                if ($updated) {
                    Cache::put("user.webphone.{$user->id}.{$user->parent_id}", 0);
                    $webphone = 0;
                }
            }

  $token = JwtToken::createToken($user->id);
                $token = $token[0];
        // Send welcome email on first Google login
        // if (!$user->first_google_login) {
        //     Mail::to($user->email)->send(new WelcomeGoogleLoginMail($user));

        //     $user->first_google_login = true;
        //     $user->save();
        // }
  $objUserExtension = UserExtension::where("username",$user->alt_extension)->first();
            $secret = $objUserExtension->secret;

            $server = AsteriskServer::find($user->asterisk_server_id);
            if (!empty($server->host)) {
                $serverHost  = $server->host;
                $domain = $server->domain;
            } else {
                $serverHost  = null;
                $domain = null;
            }
        return response()->json([
            'user' => [
                'token'=>$token,
                'id' => $user->id,
                'first_name' => $user->first_name,
                'last_name' => $user->last_name,
                'email' => $user->email,
                'mobile' => $user->mobile,
                'role' => $user->role,
                'user_level' => $user->user_level,
                'companyName' => $user->company_name,
                'companyLogo' => $user->logo,
                'profile_pic' => $user->profile_pic,
                'extension' => $user->extension,
                'alt_extension' => $user->alt_extension,
                'app_extension' => $user->app_extension,
                'server' => $serverHost,
                'domain' => $domain,
                'did'=>$user->did,
                'vm_drop'=>$user->vm_drop,
                'affiliate_link'=>$user->affiliate_link,
                'parent_id'=>$user->parent_id,
                'webphone'=>$webphone,
                "secret" => base64_encode(convert_uuencode($objUserExtension->secret))

                // Add more user fields if needed
            ]
        ]);

    } catch (\Exception $e) {
        Log::error('Google Login Exception', ['message' => $e->getMessage()]);
        return response()->json(['error' => 'Login failed.'], 500);
    }
}
  public function storeToken(Request $request)
{
    $payload = $request->all();

    // Validate input
    if (empty($payload['data']['refresh_token'])) {
        return response()->json([
            'status' => 'error',
            'message' => 'Missing refresh_token in request data.'
        ], 400);
    }

    $refreshToken = $payload['data']['refresh_token'];
    $accessToken = $payload['data']['access_token'] ?? null;

    // Step 1: If access token is missing or invalid, get a new one using refresh token
    if (!$accessToken) {
        $tokenResponse = Http::asForm()->post('https://oauth2.googleapis.com/token', [
            'client_id' => env('GOOGLE_CLIENT_ID'),
            'client_secret' => env('GOOGLE_CLIENT_SECRET'),
            'refresh_token' => $refreshToken,
            'grant_type' => 'refresh_token',
        ]);

        $tokenData = $tokenResponse->json();

        if ($tokenResponse->failed() || isset($tokenData['error'])) {
            return response()->json([
                'status' => 'error',
                'message' => 'Failed to refresh access token.',
                'google_response' => $tokenData
            ], 400);
        }

        $accessToken = $tokenData['access_token'];
    }

    // Step 2: Try to fetch user info
    $userInfoResponse = Http::withHeaders([
        'Authorization' => "Bearer {$accessToken}",
    ])->get('https://www.googleapis.com/oauth2/v2/userinfo');

    // If token invalid, retry once with refresh token
    if ($userInfoResponse->status() === 401) {
        $tokenResponse = Http::asForm()->post('https://oauth2.googleapis.com/token', [
            'client_id' => env('GOOGLE_CLIENT_ID'),
            'client_secret' => env('GOOGLE_CLIENT_SECRET'),
            'refresh_token' => $refreshToken,
            'grant_type' => 'refresh_token',
        ]);

        $tokenData = $tokenResponse->json();
        $accessToken = $tokenData['access_token'] ?? null;

        if (!$accessToken) {
            return response()->json([
                'status' => 'error',
                'message' => 'Unable to refresh access token.',
                'google_response' => $tokenData
            ], 400);
        }

        // Retry userinfo call
        $userInfoResponse = Http::withHeaders([
            'Authorization' => "Bearer {$accessToken}",
        ])->get('https://www.googleapis.com/oauth2/v2/userinfo');
    }

    if ($userInfoResponse->failed()) {
        return response()->json([
            'status' => 'error',
            'message' => 'Failed to fetch user info from Google.',
            'google_response' => $userInfoResponse->json(),
        ], 400);
    }

    $userInfo = $userInfoResponse->json();
    $email = $userInfo['email'] ?? null;

    if (!$email) {
        return response()->json([
            'status' => 'error',
            'message' => 'Email not found in user info response.',
            'user_response' => $userInfo
        ], 400);
    }

    // Save locally for now
    $dataToStore = [
        'email' => $email,
        'refresh_token' => $refreshToken,
        'fetched_at' => now()->toDateTimeString(),
    ];

    file_put_contents(
        storage_path('app/google_token_' . md5($email) . '.json'),
        json_encode($dataToStore, JSON_PRETTY_PRINT)
    );

    return response()->json([
        'status' => 'success',
        'message' => 'Refresh token stored successfully with associated email.',
        'email' => $email,
        'data' => $dataToStore
    ]);
}

}