```python
def swap_count(s):
    """
    Calculates the minimum number of swaps required to balance a bracket string.

    The string is assumed to contain an equal number of '[' and ']' characters.
    A swap can be performed between any two characters.

    The algorithm uses a greedy, two-pointer approach. A `left` pointer scans
    the string from the beginning, while a `right` pointer helps find opening
    brackets from the end when a swap is needed. A `balance` counter tracks the
    validity of the prefix scanned so far.

    When a closing bracket `]` is encountered at a point where the prefix is
    not balanced (i.e., `balance` is zero), it's considered misplaced. To fix
    this, it's swapped with the rightmost available opening bracket `[`. This
    action costs one swap. The `balance` is then updated to reflect that an
    opening bracket is now at the `left` pointer's position, and the scan continues.
    This process ensures that the prefix remains balanced at each step, and the
    total number of swaps is minimized.
    """
    if not s:
        return 0

    chars = list(s)
    n = len(chars)
    
    left = 0
    right = n - 1
    
    swaps = 0
    balance = 0

    while left < right:
        if chars[left] == '[':
            balance += 1
            left += 1
        elif chars[left] == ']':
            if balance > 0:
                balance -= 1
                left += 1
            else:
                while right > left and chars[right] == ']':
                    right -= 1
                
                if right <= left:
                    # This case should not be reached for a balanceable string
                    # where len > 0.
                    break
                
                # Perform the swap
                chars[left], chars[right] = chars[right], chars[left]
                swaps += 1
                
                # After the swap, the character at `left` is now '[',
                # which increases our balance.
                balance += 1
                
                # The '[' at `right` has been used, so move the `right`
                # pointer inwards for the next search.
                right -= 1
                
                # Move to the next character.
                left += 1
                
    return swaps
```