<p>Given a <strong>circular integer array</strong> <code>nums</code> of length <code>n</code>, return <em>the maximum possible sum of a non-empty <strong>subarray</strong> of </em><code>nums</code>.</p>

<p>A <strong>circular array</strong> means the end of the array connects to the beginning of the array. Formally, the next element of <code>nums[i]</code> is <code>nums[(i + 1) % n]</code> and the previous element of <code>nums[i]</code> is <code>nums[(i - 1 + n) % n]</code>.</p>

<p>A <strong>subarray</strong> may only include each element of the fixed buffer <code>nums</code> at most once. Formally, for a subarray <code>nums[i], nums[i + 1], ..., nums[j]</code>, there does not exist <code>i &lt;= k1</code>, <code>k2 &lt;= j</code> with <code>k1 % n == k2 % n</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,-2,3,-2]
<strong>Output:</strong> 3
<strong>Explanation:</strong> Subarray [3] has maximum sum 3.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [5,-3,5]
<strong>Output:</strong> 10
<strong>Explanation:</strong> Subarray [5,5] has maximum sum 5 + 5 = 10.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> nums = [-3,-2,-3]
<strong>Output:</strong> -2
<strong>Explanation:</strong> Subarray [-2] has maximum sum -2.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>n == nums.length</code></li>
	<li><code>1 &lt;= n &lt;= 3 * 10<sup>4</sup></code></li>
	<li><code>-3 * 10<sup>4</sup> &lt;= nums[i] &lt;= 3 * 10<sup>4</sup></code></li>
</ul>

from typing import List

class Solution:
    def maxSubarraySumCircular(self, nums: List[int]) -> int:
        n = len(nums)
        
        # Case 1: Maximum subarray sum within a contiguous segment (non-circular)
        max_kadane = self.kadane(nums)
        
        # Case 2: Maximum subarray sum that spans across the circular boundary
        # To find this, we need to compute the minimum subarray sum and subtract it from the total sum
        total_sum = sum(nums)
        for i in range(n):
            nums[i] = -nums[i]
        
        # Minimum subarray sum in the inverted array
        min_kadane = -self.kadane(nums)
        
        # If all numbers are negative, min_kadane will be equal to total_sum,
        # resulting in a max_circular_sum of 0, which is incorrect.
        # In this case, return max_kadane.
        if min_kadane == total_sum:
            return max_kadane
        
        # Maximum subarray sum spanning across the circular boundary
        max_circular = total_sum - min_kadane
        
        # Return the maximum of the two cases
        return max(max_kadane, max_circular)
    
    def kadane(self, nums: List[int]) -> int:
        max_sum = float('-inf')
        current_sum = 0
        for num in nums:
            current_sum += num
            max_sum = max(max_sum, current_sum)
            if current_sum < 0:
                current_sum = 0
        return max_sum

# Example usage:
solution = Solution()
nums = [1, -2, 3, -2]
print(solution.maxSubarraySumCircular(nums))  # Output: 3

nums = [5, -3, 5]
print(solution.maxSubarraySumCircular(nums))  # Output: 10

nums = [-3, -2, -3]
print(solution.maxSubarraySumCircular(nums))  # Output: -2
21200