";
        // print_r($data);
        $request_error_code = $data['error']['code'] ?? null;
        if (isset($request_error_code)) {
            // echo "
";
            // print_r($data);
            // echo  $request_error_code;
            // die ;
            $this->customLogWriter(storage_path('logs/MailController_flask_Api_log.txt'), 'flask method Mail Controller', $apiname . ' another no', $dataString, 1, 1);
            return [
                'message' => 'callFlaskAPI occure issue ai cant handle 15-20 request please wait and try anothor time',
                'status' => false,
                //Use the API every day for free, as long as you don’t exceed:1,500 requests per day, and 15 requests per minute, and 1 million tokens per minute
                'code' => $request_error_code //"code": 429 this belongs to handle request is | *Requests per minute (RPM)*   | *15 requests* per minute   
            ];
        }

        $decodedResponse = $data['candidates'][0]['content']['parts'][0]['text'] ?? null;
        // echo  $decodedResponse;
        // echo "hello";

        if (isset($decodedResponse)) {
            $category = $decodedResponse;

            // Return the model text as-is: callers normalise the classification
            // values themselves (aiFieldValue) and "summary" must keep its casing.
            return trim($category);
            if (strtolower(trim($category)) === "positive") {
                $result = 1;
            } elseif (strtolower(trim($category)) === "negative") {
                $result = 0;
            } elseif (strtolower(trim($category)) === "send-mail") {
                $result = 2;
            } else {
                $result = "ok"; // unknown case
            }
        } else {
            return 100;
        }
    }

    /**
     * Normalise a classification value returned by Gemini (sentiment, category,
     * action_required, mass_mail) so the switch statements keep matching
     * lowercase labels regardless of how the model cased them.
     */
    private function aiFieldValue($value)
    {
        return is_string($value) ? strtolower(trim($value)) : null;
    }

    /**
     * The account whose sentiment vocabulary applies to the signed-in user.
     *
     * Employees read their admin's labels, so both see the same filters and the
     * same numbers. Null when nobody is signed in, which falls the model back
     * to the built-in defaults.
     */
    private function sentimentOwnerId(): ?int
    {
        return Sentiment::ownerIdFor(Auth::id());
    }

    /** The account's active sentiment labels, in display order. */
    private function sentimentVocabulary()
    {
        return Sentiment::activeFor($this->sentimentOwnerId());
    }

    /** The sentiment block of the classifier prompt, built from those labels. */
    private function sentimentPromptSection(): string
    {
        return Sentiment::promptSection($this->sentimentOwnerId(), null, 8);
    }

    /** The label named in the prompt's worked example. */
    private function sentimentFallbackCode(): string
    {
        return Sentiment::fallbackCode($this->sentimentOwnerId());
    }

    /**
     * Everything the toolbar and the mail list need to render one chip per
     * sentiment, keyed by the filter slug that opens it.
     *
     * Also keyed by legacy_code and by code in the lookup arrays, because the
     * mail list has only the stored word and the stored number to work from.
     */
    private function sentimentChipDefinitions(): array
    {
        $defs = [];

        foreach ($this->sentimentVocabulary() as $sentiment) {
            $defs[$sentiment->filter_slug] = [
                'code' => $sentiment->code,
                'label' => $sentiment->name,
                'slug' => $sentiment->filter_slug,
                'colour' => $sentiment->colour,
                'hex' => $sentiment->hex(),
                'pill' => $sentiment->pillClass(),
                'legacy_code' => (int) $sentiment->legacy_code,
            ];
        }

        return $defs;
    }

    /**
     * Mail count per sentiment, keyed by filter slug.
     *
     * One grouped query rather than one per label, because the vocabulary is
     * now open-ended. The predicate matches the sentiment branch of
     * filterMails() exactly, so a chip reading 917 opens a list of 917 mails.
     *
     * @param  string|null  $excludeOwnEmail  when set, mail the user sent is left out
     * @param  bool  $excludeSpamLabel  apply the provider spam-label clause
     */
    private function sentimentCounts($userId, ?string $excludeOwnEmail = null, bool $excludeSpamLabel = true): array
    {
        $query = Message::where('user_id', $userId)
            ->where('is_promotion', '0')
            ->where('message_status', 0);

        if ($excludeOwnEmail) {
            $query->where('sender_email', '!=', $excludeOwnEmail);
        }

        if ($excludeSpamLabel) {
            $query->whereRaw('LOWER(label_ids) NOT LIKE ?', ['%spam%']);
        }

        $rows = $query->selectRaw('is_spam, COUNT(DISTINCT email_id) as total')
            ->groupBy('is_spam')
            ->pluck('total', 'is_spam');

        // Keyed by slug and zero-filled, so a label with no mail still gets a
        // chip and the sum is the sentiment total.
        $counts = [];
        foreach ($this->sentimentVocabulary() as $sentiment) {
            $counts[$sentiment->filter_slug] = (int) ($rows[(string) $sentiment->legacy_code] ?? 0);
        }

        return $counts;
    }

    /**
     * Apply one sentiment's filter to a mail listing, or return false when the
     * requested type is not a sentiment slug.
     *
     * Kept beside sentimentCounts() because the two predicates have to agree.
     */
    private function applySentimentFilter($query, string $type, bool $excludeSpamLabel = true)
    {
        $sentiment = $this->sentimentVocabulary()->firstWhere('filter_slug', $type);

        if (!$sentiment) {
            return false;
        }

        $query->where('is_spam', $sentiment->legacy_code)
            ->where('is_promotion', '=', '0')
            ->where('message_status', 0);

        if ($excludeSpamLabel) {
            $query->whereRaw('LOWER(label_ids) NOT LIKE ?', ['%spam%']);
        }

        return $sentiment->name . ' Mail';
    }

    /**
     * Clean the per-mail summary returned by the same classification prompt.
     * Casing is preserved because this is displayed to the user.
     */
    private function aiSummaryValue($value)
    {
        if (!is_string($value)) {
            return null;
        }

        $summary = trim(preg_replace('/\s+/u', ' ', strip_tags($value)));

        // The model is told to emit this only for an empty body; treat it as
        // "no usable summary" so the caller can fall back to the mail itself.
        $sentinel = strtolower(rtrim($summary, " .!"));
        if ($summary === '' || $sentinel === 'no summary available' || $sentinel === 'no summary') {
            return null;
        }

        return mb_substr($summary, 0, 1000);
    }


    public function mail_conn($email, $app_pass)
    {
        $hostname = '{imap.gmail.com:993/imap/ssl}INBOX';

        try {
            // Try to connect to Gmail IMAP
            $inbox = imap_open($hostname, $email, $app_pass);

            if (!$inbox) {
                // If connection fails, get the error message
                $errorMessage = imap_last_error();
                return [
                    'success' => false,
                    'message' => "IMAP Connection Failed: " . $errorMessage
                ];
            }

            return [
                'success' => true,
                'message' => "IMAP Connection Established Successfully!",
                "inbox" => $inbox
            ];
        } catch (\Exception $e) {
            // Handle any unexpected exceptions
            return [
                'success' => false,
                'message' => "Please send valid email or app password Exception: " . $e->getMessage()
            ];
        }
    }

    public function close_mail($inbox)
    {
        imap_close($inbox);
    }
}