";print_r($propertiesWithAlerts);die;
        return view("front.myaccount.opportunity-alerts", compact('opportunity_alerts', 'default_tab', 'propertiesWithAlerts', 'default_property_id'));
    }

    public function opportunity_alerts_detail(Request $request)
    {
        $id = $request->id;
        $user_id = $request->user()->id;
        $opportunity_alerts = OpportunityAlert::where("id", $id)->where("user_id", $user_id)->whereHas("property")->first();

        if (!$opportunity_alerts) {
            abort(404);
        }



        $other_info = json_decode($opportunity_alerts->other_info, true);
        $mdata = $other_info['mdata'];

        if ($opportunity_alerts->property_id == 82) {
            $mdata['proposed_interest_rate'] = 7.25;
            $mdata['proposed_mortgage_payment_monthly'] = 3128.95;
        }



        $subject = "";

        if ($opportunity_alerts->alert_type == "lower_rate_same_term") {
            $email_message = "Congratulations!! We have been managing your mortgage and are delighted to alert you of a refinance opportunity. Based on the information we have, you have the opportunity to refinance to get a lower rate same term and to save on interest paid over the life of the loan.";
            return (new \App\Mail\SameTermAlertMail($mdata, $email_message, $subject));
        } else if ($opportunity_alerts->alert_type == "lower_rate_not_same_term") {
            $email_message = "Congratulations!! We have been managing your mortgage and are delighted to alert you of a refinance opportunity. Based on the information we have, you have the opportunity to refinance to reduce lower rate not same term of the loan  and to save on interest paid over the life of the loan.";
            return (new \App\Mail\NotSameTermAlertMail($mdata, $email_message, $subject));
        } else if ($opportunity_alerts->alert_type == "remove_mortgage_insurance") {
            $email_message = "Congratulations!! We have been managing your mortgage and are delighted to alert you of a refinance opportunity. Based on the information we have, you have the opportunity to refinance to eliminate mortgage insurance and to save on interest paid over the life of the loan.";
            return (new \App\Mail\RemoveMortgageInsuranceAlertMail($mdata, $email_message, $subject));
        } else if ($opportunity_alerts->alert_type == "change_loan_type") {
            $email_message = "Congratulations!! We have been managing your mortgage and are delighted to alert you of a refinance opportunity. Based on the information we have, you have the opportunity to refinance to change loan type and to save on interest paid over the life of the loan.";
            return (new \App\Mail\ChangeLoanTypeAlertMail($mdata, $email_message, $subject));
        } else if ($opportunity_alerts->alert_type == "take_cash_out") {
            $email_message = "Congratulations!! We have been managing your mortgage and are delighted to alert you of a refinance opportunity. Based on the information we have, you have the opportunity to refinance to take a cashout and to save on interest paid over the life of the loan.";
            return (new \App\Mail\TakeCashOutAlertMail($mdata, $email_message, $subject));
        }
    }

    public function get_opportunity_alerts(Request $request)
    {

        $opportunity_alerts = OpportunityAlert::where("user_id", $request->user()->id)
            ->where("property_id", $request->property_id)
            ->where("alert_type", $request->alert_type)
            ->whereHas("property")
            ->orderBy("created_at", "DESC")->get();

        if ($opportunity_alerts->count() == 0) {
            return 'No Alerts Found';
        }

        $opportunity_alerts->each(function ($value) {
            $value->other_info = json_decode($value->other_info);
        });



        return view('front.myaccount.alerts-modal', compact('opportunity_alerts'));
    }

    /*
    * Author: Vidhi Shah
    * Updated date: 07 Jul 2024
    * Description: Updated code for sending contact request to Loan Officer
    *
    * Updated date: 10 Jul 2024
    * Description: Email should be sent to the default loan officer if there is not loan officer assigned to user
    */
    public function contact_loan_officer(Request $request)
    {
        $user = Auth()->user();
        try {
            $contact = ContactLoanOfficer::create([
                "officer_id" => $request->lo_id,
                "user_id" => $user->id,
                "message" => $request->message
            ]);


            $edata = [
                "name" => $user->name,
                "email"  => $user->email,
                "mobile" => $user->mobile,
                "message" => $request->message
            ];

            if (!empty($request->lo_id) && $request->lo_id > 0) {
                $getLODetails = Admin::find($request->lo_id);
                $loEmail = $getLODetails->email;
            } else {
                $loEmail = getenv("DEFAULT_LOANOFFICER_EMAIL");
            }

            Mail::to($loEmail)->send(new ContactLoanOfficerEmail($edata));
            return [
                "success" => 1,
                "message" => "Thank you for contacting us. We will get back to you shortly.",
                "redirectTo" => route("loan-officer")
            ];
        } catch (Exception $e) {
            Log::error("Error while sending contact resquet to the loan officer for user " . $user->id . ", Error - " . $e->getMessage());
            return [
                "success" => 0,
                "message" => $e->getMessage(),
                "redirectTo" => route("loan-officer")
            ];
        }
    }

    public function settings_page(Request $request)
    {
        $settings = User::select("lrst_frequency", "lrst_frequency_opt", "lrnst_frequency", "lrnst_frequency_opt", "clt_frequency", "clt_frequency_opt")->find($request->user()->id);

        return view("front.myaccount.settings", compact("settings"));
    }

    /*
    * Author: Vidhi Shah
    * Updated date: 18th Jun 2024
    * Description: This method is used to save alert frequency in the database, which will be later used for sending opportunity alerts to the user
    * Updated Date: 4th Sept 2024
    * Description: User should not allow if consent for email notification is not checked to true
    */
    public function save_settings(Request $request)
    {
        try {

            // Get the current date
            $currentDate = Carbon::now();

            // Get the day of the week as a number (1 = Monday, 7 = Sunday)
            $dayOfWeek = $currentDate->dayOfWeekIso; // Same as date('N')

            $settings = User::find($request->user()->id);

            $settings->lrst_frequency = $request->lrst_frequency;
            $settings->lrst_frequency_opt = (strtolower($request->lrst_frequency) == "weekly") ? $dayOfWeek : null;
            $settings->lrnst_frequency = $request->lrst_frequency;
            $settings->lrnst_frequency_opt = (strtolower($request->lrst_frequency) == "weekly") ? $dayOfWeek : null;
            $settings->clt_frequency = $request->lrst_frequency;
            $settings->clt_frequency_opt = (strtolower($request->lrst_frequency) == "weekly") ? $dayOfWeek : null;
            $settings->consent_to_receive_email = $request->consent_to_receive_email ?? 0;
            $settings->consent_to_receive_message = $request->consent_to_receive_message ?? 0;
            $settings->save();

            return [
                "success" => 1,
                "message" => "Successfully saved"
            ];
        } catch (\Exception $e) {
            return [
                "success" => 0,
                "message" => $e->getMessage()
            ];
        }
    }


    public function fetch_property_rentalavm(Request $request)
    {
        $user_id = auth()->user()->id;
        $property = Property::where("user_id", $user_id)->where("id", $request->property_id)->first();

        if (!$property) {
            return [
                "success" => 0,
                "message" => "Property not found"
            ];
        }

        if (empty($property->attomid)) {
            return [
                "success" => 0,
                "message" => "Attomid missing"
            ];
        }

        $address1 = $property->address;
        $address2 = $property->city . "," . $property->state;

        $property_rentalavm = (new AtomApi)->property_rentalavm($user_id, $property->id, "home-detail", "user", $address1, $address2);

        if ($property_rentalavm['success'] == 1) {
            if (!empty($property_rentalavm['response']->property[0]->rentalAvm)) {
                ///======== delete existing ==============
                // PropertyRentalAvm::where("property_id", $property->id)->delete();

                // foreach($property_rentalavm['response']->property[0]->rentalAvm as $rentalAvm) {

                $rentalAvm = $property_rentalavm['response']->property[0]->rentalAvm;
                if (isset($rentalAvm->estimatedRentalValue)) {
                    PropertyRentalAvm::create([
                        "property_id" => $property->id,
                        "estimated_rental_value" => ($rentalAvm->estimatedRentalValue ?? null),
                        "estimated_min_rental_value" => ($rentalAvm->estimatedMinRentalValue ?? null),
                        "estimated_max_rental_value" => ($rentalAvm->estimatedMaxRentalValue ?? null),
                        "valuation_date" => ($rentalAvm->valuationDate ?? null)
                    ]);
                }
                // }

            }
        }

        $rentalavms = PropertyRentalAvm::where("property_id", $property->id)->limit(1)->latest()->get();
        $rentalavms->each(function ($value) {
            $value->valuation_date1 = "";
            if ($value->valuation_date) {
                $value->valuation_date1 = $value->valuation_date->format('m-d-Y');
            }

            $value->estimated_rental_value = "$" . number_format($value->estimated_rental_value);
            $value->estimated_min_rental_value = "$" . number_format($value->estimated_min_rental_value);
            $value->estimated_max_rental_value = "$" . number_format($value->estimated_max_rental_value);
        });

        return [
            "success" => 1,
            "message" => "",
            "rentalavms" => $rentalavms
        ];
    }

    public function delete_property(Request $request)
    {
        $user_id = $request->user()->id;
        $property = Property::where("id", $request->property_id)->where("user_id", $user_id)->first();

        if (!$property) {
            return [
                "success" => 0,
                "message" => "Property does not exists"
            ];
        }

        $property->delete();

        return [
            "success" => 1,
            "message" => "Property successfully removed. Please wait we are redirecting."
        ];
    }


    public function get_a_rate_quote(Request $request)
    {
        // return $request->all();
        $property_id = $request->property_id;
        $user_id = auth()->user()->id;

        $property = Property::where("user_id", $user_id)->where("id", $property_id)->first();

        if (!$property) {
            return [
                "success" => 0,
                "message" => "Property not found"
            ];
        }


        $address1 = $property->address;
        $address2 = $property->city . "," . $property->state;

        $errors_array = [];
        $property_expandedprofile = (new AtomApi)->property_expandedprofile($user_id, $property_id, "all-property", "user", $address1, $address2);
        $attomId = $property_expandedprofile['response']->property[0]->identifier->attomId;
        if ($property_expandedprofile['success'] == 1) {
            
            $allevents_details = $this->allevents_details($property->user_id, $property->id, "atom-property-services", "jobs", $attomId);
            $current_estimated_home_value = "";
            if($allevents_details['success'] == 1) {
                if(!empty($allevents_details['response']->property)) {
                    $current_estimated_home_value = $allevents_details['response']->property[0]->avm->amount->value ?? null;
                }
            }

            $property->number_of_bedrooms = $property_expandedprofile['response']->property[0]->building->rooms->beds ?? null;
            $property->number_of_bathrooms = $property_expandedprofile['response']->property[0]->building->rooms->bathsTotal ?? null;
            $property->size_sqft = $property_expandedprofile['response']->property[0]->building->size->livingSize ?? null;
            $property->current_estimated_home_value = $current_estimated_home_value ?? $property_expandedprofile['response']->property[0]->assessment->market->mktTtlValue ?? null;

            $property->attomid = $property_expandedprofile['response']->property[0]->identifier->attomId ?? null;
            $property->geoidv4_n1 = $property_expandedprofile['response']->property[0]->location->geoIdV4->N1 ?? $property_expandedprofile['response']->property[0]->location->geoIdV4->N2 ?? null;

            $property->save();
        } else {
            $errors_array[] = "Property Detail: " . $property_expandedprofile['message'];
        }

        //// current estimated home value===========================
        $allevents_details = (new AtomApi)->allevents_details($user_id, $property_id, "all-property", "user", $property->attomid);

        if ($allevents_details['success'] == 1) {
            if (!empty($allevents_details['response']->property)) {
                $property->current_estimated_home_value = $allevents_details['response']->property[0]->avm->amount->value ?? null;
                $property->save();
            }
        }


        /*
        $valuation_homeequity = (new AtomApi)->valuation_homeequity($user_id, $property_id, "all-property", "user", $address1, $address2);

        if($valuation_homeequity['success'] == 1) {
            $property->estimated_home_equity = $valuation_homeequity['response']->property[0]->homeEquity->estimatedAvailableEquity;
            $property->save();
        } else {
            $errors_array[] = "Home Equity: " . $valuation_homeequity['message'];
        }

        if(count($errors_array) == 2) {
            return [
                "success" => 0,
                "message" => implode(",", $errors_array)
            ];
        }
        */

        if (floatval($property->current_estimated_home_value ?? 0) > 0) {
            $total_loan_balance = $property->mortgage_informations->sum("current_loan_balance");
            $property->estimated_home_equity = ($property->current_estimated_home_value - $total_loan_balance);
        }

        $property->current_estimated_home_value = number_format($property->current_estimated_home_value);
        $property->estimated_home_equity = number_format($property->estimated_home_equity);

        //////call opportunity alerts ==============
        if (count($errors_array) == 0) {
            (new OpportunityAlertsServices())->removeMortgageInsuranceAlerts($property->id);
            (new OpportunityAlertsServices())->takeCashOutAlerts($property->id);
            (new OpportunityAlertsServices())->lowerRateSameTermAlerts($property->id, $property->user_id);
            (new OpportunityAlertsServices())->lowerRateNotSameTermAlerts($property->id, $property->user_id);
            //(new OpportunityAlertsServices())->changeLoanTypeAlerts($property->id, $property->user_id);

            $opp_alerts = collect(DB::select('SELECT alert_type, COUNT(*) AS total_new_alerts FROM `opportunity_alerts` WHERE property_id = ? AND read_status = 0 GROUP BY alert_type', [$property->id]));
            $opp_alerts = $opp_alerts->map(function ($alert) use ($property_id) {
                $alert_type_desc = "";
                $alert_link = "";
                if ($alert->alert_type == "lower_rate_same_term") {
                    $alert_type_desc = "Lower Rate Same Term";
                    $alert_link = route("opportunity-alerts", ["property_id" => $property_id, "f" => "lrst"]);
                } else if ($alert->alert_type == "lower_rate_not_same_term") {
                    $alert_type_desc = "Lower Rate But Not Same Term";
                    $alert_link = route("opportunity-alerts", ["property_id" => $property_id, "f" => "lrnst"]);
                } else if ($alert->alert_type == "change_loan_type") {
                    $alert_type_desc = "Change Loan Type";
                    $alert_link = route("opportunity-alerts", ["property_id" => $property_id, "f" => "clt"]);
                } else if ($alert->alert_type == "take_cash_out") {
                    $alert_type_desc = "Take Cashout";
                    $alert_link = route("opportunity-alerts", ["property_id" => $property_id, "f" => "tco"]);
                } else if ($alert->alert_type == "remove_mortgage_insurance") {
                    $alert_type_desc = "Remove Mortgage Insurance";
                    $alert_link = route("opportunity-alerts", ["property_id" => $property_id, "f" => "rmi"]);
                }

                return [
                    "alert_type_desc" => $alert_type_desc,
                    "alert_type" => $alert->alert_type,
                    "alert_link" => $alert_link,
                    "total_new_alerts" => $alert->total_new_alerts
                ];
            });
        } else {
            $opp_alerts = [];
        }

        return [
            "success" => 1,
            "message" => implode(",", $errors_array),
            "property" => $property,
            "opp_alerts" => $opp_alerts
        ];
    }


    public function runAttomForAllProperty()
    {
        $properties = Property::get();

        $properties->each(function ($property) {
            $property_id = $property->id;
            dispatch(function () use ($property_id) {
                $service = new AtomPropertyServices;
                $service->call_property_expandedprofile($property_id);
                // $service->call_near_by_schools($property_id);
                // $service->call_transportation_noise($property_id);
                $service->call_sales_trend($property_id);
                $service->call_property_detailmortgage($property_id);
                $service->call_allevents_detail($property_id);
                // $service->call_property_detailowner($property_id);
                // $service->call_property_buildingpermits($property_id);
                $service->call_property_rentalavm($property_id);
            });
        });
    }
    /*
    * Author: Vidhi Shah
    * Updated date: 3rd Jul 2024
    * Description: Get loan officer's details
    *
    * Updated date: 10 Jul 2024
    * Description: Assigning default loan officer's data
    */
    public function loanOfficer()
    {
        try {

            $user = auth()->user();
            $properties = Property::where("user_id", $user->id)->first();
            /* Default laon office is admin with ID 1 */
            $assigned_to = $properties->assigned_to > 0 ? $properties->assigned_to : (!empty($user->assigned_to && $user->partner_id > 0) ? $user->assigned_to : 1);
            
            $loanOfficerDetails = ($assigned_to > 0 && ($admin = Admin::find($assigned_to))) ? $admin : (object) [
                'id' => 0,
                'name' => getenv("DEFAULT_LOANOFFICER_NAME"),
                'email' => getenv("DEFAULT_LOANOFFICER_EMAIL"),
                'mobile' => getenv("DEFAULT_LOANOFFICER_MOBILE"),
                'nmls_number' => getenv("DEFAULT_LOANOFFICER_NMLS_ID"),
            ];

        } catch (Exception $e) {
            $loanOfficerDetails = [];
            Log::error($e->getMessage());
        }

        return view('front.myaccount.loan-officer', compact('loanOfficerDetails'));
    }

    public function newRate()
    {
        return view('front.myaccount.new-rate');
    }

    public function referFriend()
    {
        return view('front.myaccount.referFriend');
    }

    /**
     * Author: Vidhi Shah
     * Added date: 16th Sept 2024
     * Description: For call APIs for refinancing alerts
     */
    public function get_alerts(Request $request)
    {

        session(['processing_alert_after_login' => 1]);
        session(['processing_alert_after_login_done' => 0]);
        $myproperties = Property::where("user_id", auth()->user()->id)->get();

        try {
            foreach ($myproperties as $property) {
                if ($this->isPropertyComplete($property)) {
                    (new OpportunityAlertsServices())->updateCurrentLoanBalance($property->id);
                    (new OpportunityAlertsServices())->removeMortgageInsuranceAlerts($property->id);
                    (new OpportunityAlertsServices())->takeCashOutAlerts($property->id);
                    (new OpportunityAlertsServices())->lowerRateSameTermAlerts($property["id"], auth()->user()->id, false);
                    (new OpportunityAlertsServices())->lowerRateNotSameTermAlerts($property["id"], auth()->user()->id, false);
                }
            };
        } catch (Exception $e) {
            Log::error("After login, Lenderprice API call causing issue - " . $e->getMessage());
        }

        $opportunity_alerts = OpportunityAlert::where("user_id", auth()->user()->id)
            ->orderBy("created_at", "DESC")->count();


        if ($opportunity_alerts > 0) {
            $alerts_count = $opportunity_alerts;
        } else {
            $alerts_count = 0;
        }

        session(['processing_alert_after_login' => 0]);
        session(['processing_alert_after_login_done' => 1]);

        return $alerts_count;
    }

    
    /**
     * Author: Vidhi Shah
     * Added date: 16th Sept 2024
     * Description: For managing session flag to check whether APIs get called and ran once after success full login
     */
    public function manage_alert_sessions()
    {
        session(['processing_alert_after_login' => 0]);
        session(['processing_alert_after_login_done' => 1]);        
    }

    private function processDocument($fileName)
    {
        // Construct the full file path
        $filePath = storage_path('app/public/mortgage_statements/' . $fileName);

        // Instantiate the DocumentProcessorServiceClient
        $client = new DocumentProcessorServiceClient();

        // Build the processor name using project ID, location, and processor ID
        $name = $client->processorName($this->projectId, $this->location, $this->processorId);

        // Read the file content
        $fileContent = file_get_contents($filePath);

        // Determine the MIME type of the file
        $mimeType = mime_content_type($filePath);

        // Validate MIME type (ensure it's supported)
        $supportedMimeTypes = ['application/pdf', 'image/jpeg', 'image/png'];
        if (!in_array($mimeType, $supportedMimeTypes)) {
            return ['error' => 'Unsupported file type: ' . $mimeType];
        }

        // Create a RawDocument instance
        $rawDocument = new RawDocument([
            'content' => $fileContent,
            'mime_type' => $mimeType, // Use the dynamically detected MIME type
        ]);

        // Create a ProcessRequest instance and set the processor name and raw document
        $request = new ProcessRequest();
        $request->setName($name);
        $request->setRawDocument($rawDocument);

        // Initialize a response variable
        $response = null;

        // Call the API and handle any potential exceptions
        try {
            $response = $client->processDocument($request);
        } catch (\Exception $e) {
            // Handle API errors gracefully
            return ['error' => $e->getMessage()];
        }

        // Parse the response to get the processed document
        $document = $response->getDocument();

        // Extract desired fields from the document
        $fields = $this->extractFields($document);

        // Close the client to free up resources
        $client->close();

        // Return the extracted fields
        return $fields;
    }


    private function extractFields($document)
    {
        $fields = [];

        // Loop through the entities and extract specific fields
        foreach ($document->getEntities() as $entity) {
            $type = $entity->getType();
            $text = $entity->getMentionText();

            // Map extracted fields to specific keys
            switch ($type) {
                case 'PropertyAddress':
                    $fields['property_address'] = $text;
                    break;
                case 'OutstandingBalance':
                    $fields['outstanding_balance'] = $text;
                    break;
                case 'InterestRate':
                    $fields['interest_rate'] = $text;
                    break;
                case 'LoanNumber':
                    $fields['loan_number'] = $text;
                    break;
                case 'PaymentDueDate':
                    $fields['payment_due_date'] = $text;
                    break;
                case 'AmountDue':
                    $fields['amount_due'] = $text;
                    break;
                    // Add additional cases for other fields as needed
                default:
                    // For other fields not mapped explicitly
                    $fields[$type] = $text;
                    break;
            }
        }

        $address = $this->parseAddress($fields['property_address']);
        $fields['property_address'] = (!empty($address['address'])) ? $address['address'] : "";
        $fields['state'] = (!empty($address['state'])) ? $address['state'] : "";
        $fields['zip_code'] = (!empty($address['zip_code'])) ? $address['zip_code'] : "";

        // Check if maturity_date exists and is in valid format
        if (isset($fields['maturity_date']) && \DateTime::createFromFormat('m/d/Y', $fields['maturity_date'])) {
            // Create a Carbon instance from the maturity date
            $maturity_date = Carbon::createFromFormat('m/d/Y', $fields['maturity_date']);
            $loan_term_years = 30;  // Assuming it's a 30-year loan

            // Subtract loan term from maturity date to get the start date
            $start_date = $maturity_date->copy()->subYears($loan_term_years);

            // Add start_date to the fields array
            $fields['start_date'] = $start_date->format('m-Y'); // Format as needed - 10-25-2024
        } else {
            // If maturity_date does not exist or is invalid, leave start_date blank
            $fields['start_date'] = '';
        }

        return $fields;
    }

    /**
     * Author: Gurupriya Solanki
     * Descrption : Calling by Ajax call to get fields data to show property data by auto populate
     * Created Date : 9 OCT 2024
     */
    public function uploadAndProcessDocument(Request $request)
    {
        // Handle file upload and store it
        try {
            if ($request->has('mortgage_statement')) {
                $orignal_filename = $request->file('mortgage_statement')->getClientOriginalName();
                $extension = pathinfo($orignal_filename, PATHINFO_EXTENSION);

                /* Author: Vidhi Shah
                * Update Date: 15 Nov 2024
                * Description: should allow image files as well*/
                if (!in_array($extension, ["pdf", "xls", "xlsx", "jpeg", "png", "jpg"])) {
                    return response()->json([
                        "success" => 0,
                        "message" => "Please upload pdf/xls/xlsx/jpeg/jpg/png file only"
                    ]);
                }

                $mortgage_statement = basename($request->file('mortgage_statement')->store('public/mortgage_statements'));

                // Process the document with Document AI
                $extractedData = $this->processDocument($mortgage_statement);

                // Return the extracted fields as a JSON response
                return response()->json([
                    'success' => true,
                    'fields' => $extractedData,
                ]);
            } else {
                return response()->json([
                    'success' => false,
                    'message' => 'No file uploaded',
                ]);
            }
        } catch (\Exception $e) {
            // Handle any errors that may occur
            return response()->json([
                'success' => false,
                'error' => $e->getMessage(),
            ], 500);
        }
    }

    /* Parse address from mortgage statement and get city, state and zipcode */
    public function parseAddress($address)
    {

        // Regular expression to extract city, state, and ZIP code
        $pattern = '/([A-Za-z\s]+),?\s*([A-Z]{2})\s*(\d{5})/';

        // Initialize result array
        $result = [
            'city' => null,
            'state' => null,
            'zip_code' => null
        ];

        // Check if the address matches the pattern
        if (preg_match($pattern, $address, $matches)) {
            // Populate the result with matches
            $result['address'] = trim($address);
            $result['city'] = trim($matches[1]);
            $result['state'] = $matches[2];
            $result['zip_code'] = $matches[3];
        }

        return $result;
    }

    public function fetch_mortgage_atomapi_by_address(Request $request)
    {
        $address1 = $request->address;
        $address2 = "{$request->city}, {$request->state}";
        $user_id = auth()->id();
        $bypass_property_check = $request->bypass_property_check ?? false;
        $current_interest_rate = $request->current_interest_rate ?? 0;
        // Check if property already exists
        if (!$bypass_property_check && Property::where([
            "address" => $request->address,
            "city" => $request->city,
            "zipcode" => $request->zipcode,
            "occupancy" => $request->occupancy
        ])->exists()) {
            return ["success" => 0, "message" => "Oops! This property already exists in our database"];
        }

        // Fetch property profile from AtomApi
        $property_expandedprofile = (new AtomApi)->property_expandedprofile($user_id, 0, "add-property", "user", $address1, $address2);
        $attomId = $property_expandedprofile['response']->property[0]->identifier->attomId;
        $allevents_details = (new AtomApi)->allevents_details($user_id, 0, "add-property", "user", $attomId);
        $current_estimated_home_value = "";
        if($allevents_details['success'] == 1) {
            if(!empty($allevents_details['response']->property)) {
                $current_estimated_home_value = $allevents_details['response']->property[0]->avm->amount->value ?? null;
            }
        }
        $property = $property_expandedprofile['response']->property[0] ?? null;

        if (!$property) {
            return ["success" => 0, "message" => "Property details not found"];
        }

        // Extract mortgage details
        $mortgage = $property->assessment->mortgage->FirstConcurrent ?? null;
        $original_loan_balance = $mortgage->amount ?? 0;

        // Convert mortgage_start_date to MM-YYYY format
        $mortgage_start_date_raw = !empty($mortgage->date) ? Carbon::parse($mortgage->date)->format('m-Y') : "";
        
        // Extract property sale details
        $appraised_proprty_value = $current_estimated_home_value ?? $property->assessment->market->mktTtlValue 
        ?? $property->assessment->assessed->assdTtlValue 
        ?? 0;

        // Calculate current loan balance
        $current_loan_balance = "";
        if(!empty($current_interest_rate) && is_numeric($current_interest_rate) && $current_interest_rate > 0){
            $loan_term = 360; 
            // Validate & convert mortgage start date
            if (preg_match('/^\d{2}-\d{4}$/', $mortgage_start_date_raw)) {
                // Convert "MM-YYYY" to "YYYY-MM-01"
                $parts = explode('-', $mortgage_start_date_raw);
                $mortgage_start_date = "{$parts[1]}-{$parts[0]}-01"; // Convert to "YYYY-MM-01"
            } else {
                $mortgage_start_date = $mortgage_start_date_raw;
            }
            $current_loan_balance = getCurrentLoanBalance($original_loan_balance, $current_interest_rate, $loan_term, $mortgage_start_date) ?? 0;    
            $current_loan_balance =  number_format($current_loan_balance, 2);
        }
        
        return [
            "success" => 1,
            "message" => "Mortgage and summary data retrieved successfully",
            "current_estimated_home_value" => number_format($appraised_proprty_value, 2),
            "all_events_current_estimated_home_value" => number_format($current_estimated_home_value,2),
            "mortgage_start_date" => $mortgage_start_date_raw,
            "original_loan_balance" => number_format($original_loan_balance, 2),
            "current_loan_balance" => $current_loan_balance,
            "loan_type" => "Fixed",
            "loan_program" => "Conventional",
            "loan_term" => 360
        ];
    }

    function calculateCurrentLoanBalance(Request $request) {
        try {
            // Sanitize and retrieve input values
            $original_loan_balance = removeCommaFromAmount($request->get("original_loan_balance"));
            $current_interest_rate = $request->get("current_interest_rate");
            $loan_term = $request->get("loan_term");
            $mortgage_start_date_raw = $request->get("mortgage_start_date");
    
            // Log received request data
            Log::info("Processing loan balance calculation", [
                'original_loan_balance' => $original_loan_balance,
                'current_interest_rate' => $current_interest_rate,
                'loan_term' => $loan_term,
                'mortgage_start_date_raw' => $mortgage_start_date_raw,
            ]);
    
            // Validate numeric inputs
            if (!is_numeric($original_loan_balance) || !is_numeric($current_interest_rate) || !is_numeric($loan_term)) {
                Log::error("Invalid numeric values", [
                    'original_loan_balance' => $original_loan_balance,
                    'current_interest_rate' => $current_interest_rate,
                    'loan_term' => $loan_term,
                ]);
                return response()->json(['success' => 0, 'error' => 'Invalid numeric values provided.'], 400);
            }
    
            // Validate & convert mortgage start date
            if (preg_match('/^\d{2}-\d{4}$/', $mortgage_start_date_raw)) {
                // Convert "MM-YYYY" to "YYYY-MM-01"
                $parts = explode('-', $mortgage_start_date_raw);
                $mortgage_start_date = "{$parts[1]}-{$parts[0]}-01"; // Convert to "YYYY-MM-01"
            } else {
                $mortgage_start_date = $mortgage_start_date_raw;
            }
    
            // Parse the date using Carbon
            try {
                $mortgage_start_date = Carbon::parse($mortgage_start_date)->format('Y-m-d');
            } catch (Exception $e) {
                Log::error("Invalid mortgage start date format", ['input' => $mortgage_start_date_raw, 'error' => $e->getMessage()]);
                return response()->json(['success' => 0, 'error' => 'Invalid mortgage start date format. Expected format: MM-YYYY or YYYY-MM-DD.'], 400);
            }
    
            // Calculate loan balance
            $current_loan_balance = getCurrentLoanBalance($original_loan_balance, $current_interest_rate, $loan_term, $mortgage_start_date) ?? 0;
    
            Log::info("Successfully calculated loan balance", ['current_loan_balance' => $current_loan_balance]);
    
            return response()->json(['success' => 1, 'current_loan_balance' => number_format($current_loan_balance, 2)], 200);
        } catch (Exception $e) {
            Log::error("Unexpected error in loan balance calculation", ['error' => $e->getMessage()]);
            return response()->json(['success' => 0, 'error' => 'An unexpected error occurred. Please try again later.'], 500);
        }
    }

}