```

1. Application Overview

    Purpose: To check the connectivity of specified Tor bridges while allowing users to apply filters for improved results and manage data visually.
    Platform: Desktop application with a GUI using PyQt5.

2. Components

A. Input Section

    Network Interface Display
        Purpose: Display the available network interfaces.
        Details:
            Read-only text area showing all network interfaces (e.g., eth0, wlan0).
            Automatically updates when the application starts.

    Bridges Input
        Purpose: User input area for listing bridges.
        Details:
            Multi-line text input where users can enter multiple bridges.
            Example formats accepted:
                192.168.0.1:443
                obfs4 185.117.153.235:80 7365271E0F03600D8566D414F755D04AE8585FCE

    Check Bridges Button
        Purpose: Initiates the connectivity check for the bridges entered.
        Behavior:
            Validates the input.
            Runs checks for each bridge using network sockets.

B. Country Selection Section

    Country Code Buttons
        Purpose: Select countries to exclude from results based on geo-location.
        Details:
            Buttons corresponding to each available country code (e.g., US, FR, DE).
            Toggle-able (checked/unchecked).
            States are stored for use in filtering results.

    Select All / Deselect All Buttons
        Purpose: Quickly manage country selections.
        Behavior:
            Clicking "Select All" checks all country buttons.
            Clicking "Deselect All" unchecks all country buttons.

C. Filter Section

    Filter Input Field
        Purpose: Input field for user-defined filters (wildcards, clones).
        Details:
            Accepts patterns such as:
                *.example.com (wildcard matching)
                192.168.*.* (subnet matching)
                clone* (to filter out clones)
            Placeholder text: "Enter filter pattern (e.g., clone# for subnets)."

    Active Blacklisted Filters List
        Purpose: Display currently active filters applied to the bridges.
        Details:
            List view showing all filters added by the user.
            Allows for selection and removal of filters.

    Add / Remove Filter Buttons
        Purpose: Manage active filters.
        Behavior:
            Clicking "Add" submits the current filter from the input field to the list.
            Clicking "Remove" deletes selected filters from the active list.

D. Results Section

    Results Display Table
        Purpose: Show the results of the bridge checks in an organized format.
        Columns:
            ccTLD: Two-character country code for each bridge.
            Bridge: Detailed string of the bridge in the format IP:Port or type IP:Port key.
            RTT (ms): Round Trip Time measured in milliseconds.
        Sorting: Clickable headers to sort by ccTLD, Bridge, or RTT.

    Console Log
        Purpose: Log display for errors, messages, and actions taken within the application.
        Details:
            Displays messages such as "Total bridges checked: X" and any errors that occur during filtering/checking.

3. Functional Logic

A. Bridge Checking Logic

    Parse the entered bridge data for correctness.
    Connect to each bridge socket to measure RTT.
    Collect and store results in a structured format for display.

B. Filtering Logic

    Exclusion by Country Code: Remove bridges that match the selected country codes.
    Clone Filtering Logic:
        Input like clone filters to keep one bridge from each unique first octet.
        Input like cloneclone filters to keep one bridge for each unique pair of the first two octets.

4. Error Handling

    Input validation for both bridge entries and filter patterns.
    Prevent actions on table items that have been filtered out or removed.
1. Application Overview

    Name: Tor Bridge Connectivity Checker
    Purpose: Validate connectivity to specified Tor bridges, applying flexible user-defined filters. Display results in an organized and sortable format.

2. Components

A. Input Section

    Network Interface Display
        Type: Read-Only Text Area
        Function: Automatically fetch and display available network interfaces (e.g., eth0, wlan0).
        Behavior: Updates upon application launch.

    Bridges Input Area
        Type: Multi-Line Text Input
        Expected Formats:
            192.168.0.1:443
            obfs4 185.117.153.235:80 7365271E0F03600D8566D414F755D04AE8585FCE
        Validation: Checks each entry for correct syntax before initiating checks.

    Check Bridges Button
        Type: Push Button
        Function: Starts the checking process for the entered bridges.
        Behavior:
            Validates input.
            Initiates connectivity checks asynchronously.

B. Country Selection Section

    Country Code Selectable Buttons
        Type: Button Group
        Function: Each button corresponds to a two-character country code (e.g., US, DE).
        Behavior:
            Toggle-able selection (checked/unchecked).
            Results will exclude bridges from selected countries.

    Select All / Deselect All Buttons
        Type: Push Buttons
        Function: Manage country button state easily.
        Behavior:
            "Select All": Checks all country buttons.
            "Deselect All": Unchecks all country buttons.

C. Filtering Section

    Pattern Filter Input Field
        Type: Text Input
        Expected Inputs:
            Wildcards: *.example.com
            Subnets: 192.168.*.*
            Clones:
                clone (remove one bridge for each unique first octet)
                cloneclone (remove one bridge for each unique pair of first two octets)
        Placeholder: "Enter filter pattern (e.g., clone# for subnets)."
        Validation: Accepts valid patterns; displays error for invalid patterns.

    Active Blacklisted Filters List
        Type: List Widget
        Function: Displays currently active user-defined filters.
        Behavior: Allows users to select and remove filters from the list.

    Add / Remove Filter Buttons
        Type: Push Buttons
        Function: Manage filters in the active filter list.
        Behavior:
            "Add Filter": Takes the pattern from the input field and adds it to the list.
            "Remove Selected Filter": Deletes selected filter(s) from the list.

D. Results Section

    Results Display Table
        Type: Table Widget
        Columns:
            ccTLD: Displays country code (2 characters).
            Bridge: Displays the bridge string in the format IP:Port or type IP:Port key.
            RTT (ms): Displays Round Trip Time in milliseconds.
        Functionality:
            Sorting by clicking on column headers.
            Automatically resize columns according to content, maintaining minimal width for ccTLD and RTT.

    Console Log
        Type: Read-Only Text Area
        Function: Show logs of actions taken, errors encountered, and status messages (e.g., "Total bridges checked: X").
        Detail Messages: Should clarify actions (e.g., "Filtered to [value]").

3. Functional Logic

A. Bridge Checking Logic

    Entry Inspection: Validate each bridge format before processing.
    Connection Procedure:
        Establish socket connections to each bridge to measure RTT.
        Collect successful connections and their respective latencies.

B. Filtering Logic

    Country Code Exclusion: Filter out bridges from selected countries.
    Cloning Logic:
        On input clone: Retain only one instance of bridges with the same first octet.
        On input cloneclone: Retain only one instance of bridges with the same first two octets.
1. Application Overview

    Name: Tor Bridge Connectivity Checker
    Purpose: This application validates connectivity to specified Tor bridges, allowing users to apply advanced filters to narrow down results based on country codes and IP clone patterns. The results are displayed in a sortable table format.

2. Components

A. Input Section

    Network Interface Display
        Type: QPlainTextEdit (Read-Only)
        Function: Automatically retrieves and displays all available network interfaces.
        Expected Behavior:
            Displays interfaces such as eth0, wlan0, etc.
            Updates upon application launch.
            Should have a maximum height (e.g., 30 pixels) to maintain UI cleanliness.

    Bridges Input Area
        Type: QPlainTextEdit
        Expected Input Formats:
            Standard IP format: 192.168.0.1:443
            Obfuscated bridge format: obfs4 185.117.153.235:80 7365271E0F03600D8566D414F755D04AE8585FCE
        Validation:
            Each line must adhere to the specified format.
            Error messages should be displayed in the console for invalid entries.
        Placeholder Text: "List each bridge on a new line."

    Check Bridges Button
        Type: QPushButton
        Label: "Check Bridges"
        Function: Initiates the connectivity check for the bridges entered.
        Behavior:
            Validates user input.
            Calls the bridge checking logic asynchronously to prevent UI freezing.
            Logs results and errors in the console.

B. Country Selection Section

    Country Code Selectable Buttons
        Type: QPushButton (one per country code)
        Expected Labels: Two-character country codes like US, CA, DE, etc.
        Function: Allows users to select countries they want to exclude from results.
        Behavior:
            Each button toggles its checked state (selected/deselected).
            Updates the self.selected_countries set with currently excluded codes.
            On selection change, updates the interface visually (e.g., changes background color when selected).
            Should not require Y-scroll; fit within set height constraints.

    Select All / Deselect All Buttons
        Type: QPushButton
        Labels: "Select All" and "Deselect All"
        Function: Manage the selection state of country buttons.
        Behavior:
            "Select All": Checks all country code buttons.
            "Deselect All": Unchecks all country code buttons.

C. Filtering Section

    Pattern Filter Input Field
        Type: QPlainTextEdit
        Placeholder Text: "Enter filter pattern (e.g., clone# for subnet filtering)."
        Expected Inputs:
            Wildcards: *.example.com
            Subnets: 192.168.*.*
            Clones:
                clone (handles only the first octet)
                cloneclone (handles the first two octets)
                Examples of more complex filters can include:
                    111.*.*.*
                    *.111.*.*
                    *.*.111.*
                    *.*.*.111
        Validation: On entering a pattern, it should confirm if it's valid to prevent errors.

    Active Blacklisted Filters List
        Type: QListWidget
        Function: Displays currently active filters applied to the bridges.
        Behavior:
            Allows users to select a filter for removal.
            Updates dynamically as filters are added or removed.

    Add / Remove Filter Buttons
        Type: QPushButton
        Labels: "Add Filter", "Remove Selected Filter"
        Add Filter Button:
            Takes the input from the filter field and appends it to the Active Filters List.
        Remove Filter Button:
            Deletes the currently selected filter(s) from the Active Filters List.
        Validation: Inform the user if attempting to add an already existing filter in the list.

D. Results Section

    Results Display Table
        Type: QTableWidget
        Column Labels:
            ccTLD: Two-character country code.
            Bridge: Complete string representation of the bridge.
            RTT (ms): Measured Round Trip Time in milliseconds.
        Expected Behavior:
            Supports sorting by clicking on column headers.
            Sorting for:
                ccTLD: Alphabetical sorting (A-Z).
                Bridge: Numeric sorting for IP addresses.
                RTT (ms): Numeric sorting based on latency.
        Column Width Adjustments:
            ccTLD: Fixed width, not exceeding 50 pixels.
            RTT: Fixed width, e.g., 70 pixels.
            Bridge: Auto-adjust width to fill remaining space.

    Console Log
        Type: QPlainTextEdit
        Function: Read-only log display.
        Expected Messages:
            Status updates: "Total bridges checked: X"
            Error messages on invalid actions: "Invalid filter pattern."

3. Functional Logic

A. Bridge Checking Logic

    Validation of Entries:
        Each entry's format must adhere to expected patterns for both the standard and obfuscated forms.
    Connectivity Check Logic:
        Upon pressing the "Check Bridges" button, initiate async connection attempts for each bridge.
        Measure and record RTT for each successful connection attempt.
        Use a QThread worker to handle checks for responsive behavior of the UI.

B. Filtering Logic

    Country Code Exclusion:
        Check IP addresses against selected country codes and exclude corresponding bridges from results.
    Cloning Logic:
        Filter logic to identify and retain:
            One bridge for each unique first octet for clone
            One bridge for each unique pair of first two octets for cloneclone
    Dynamic Pre-Filtering and Post-Filtering:
        Apply filters dynamically before initiating bridge checks and after results are displayed.

4. Error Handling

    User Input Validation:
        Show a user-friendly error message in the console if the input format is incorrect.
    Access Controls:
        Ensure attempts to access filtered-out results don’t cause application errors by verifying item existence before operations.

5. User Interaction Enhancements

    Keyboard Shortcuts:
        Implement Enter key functionality to trigger the Add Filter action.
    Help System:
        An integrated help button gives contextual information on valid input formats and functionality.

6. User Interface and Style

    Design Theme:
        A cohesive dark theme across the application for better visibility and reduced eye strain.
    Layout Improvements:
        Optimize the layout to remove redundant scroll bars and maximize space utilization.
    Column Width Control:
        Ensure proper column auto-sizing based on content while maintaining a professional appearance.
1. Application Overview

    Name: Tor Bridge Connectivity Checker
    Purpose: To validate connectivity to specified Tor bridges, allowing users to apply flexible filters to eliminate duplicate 'clone' IPs based on user-defined criteria. Results are displayed in an organized, sortable manner.

2. Components

A. Input Section

    Network Interface Display
        Type: QPlainTextEdit (Read-Only)
        Function: Displays all available network interfaces (e.g., eth0, wlan0).
        Behavior: Updates upon application launch.

    Bridges Input Area
        Type: QPlainTextEdit
        Expected Input Formats:
            Standard format: 192.168.0.1:443
            Obfuscated format: obfs4 185.117.153.235:80 7365271E0F03600D8566D414F755D04AE8585FCE
        Validation: Each entry must conform to valid syntax; errors must display in the console.

    Check Bridges Button
        Type: QPushButton
        Label: "Check Bridges"
        Function: Initiates the checking process for the bridges entered.
        Behavior: Validates user input and launches the connectivity checks asynchronously.

B. Country Selection Section

    Country Code Selectable Buttons
        Type: QPushButton (one for each country code)
        Function: Allows users to select countries to exclude from the results.
        Behavior: Toggles checked state; updates the self.selected_countries set accordingly.

    Select All / Deselect All Buttons
        Type: QPushButton
        Labels: "Select All" and "Deselect All"
        Function: Manage the selection state of country buttons.

C. Filtering Section

    Pattern Filter Input Field
        Type: QPlainTextEdit
        Placeholder Text: "Enter filter pattern (e.g., clone# for subnet filtering)."
        Expected Inputs:
            Wildcards: *.example.com
            Subnet ranges: 192.168.0.1-192.168.0.255
        Clone Handling Logic:
            clone# where # specifies the octet position for filtering:
                clone1: Filters based on the first octet.
                clone2: Filters based on the second octet.
                clone3: Filters based on the third octet.
                clone4: Filters based on the fourth octet.
        Validation: Correctly validates these inputs to avoid erroneous entries.

    Active Blacklisted Filters List
        Type: QListWidget
        Function: Displays currently active user-defined filters.
        Behavior: Allows removal of selected filters.

    Add / Remove Filter Buttons
        Type: QPushButton
        Labels: "Add Filter", "Remove Selected Filter"
        Behavior:
            "Add Filter": Takes the input from the filter field and adds it to the list.
            "Remove Selected Filter": Deletes the selected filter(s) from the list.

D. Results Section

    Results Display Table
        Type: QTableWidget
        Columns:
            ccTLD: Two-character country code.
            Bridge: Shows the bridge string in the required format.
            RTT (ms): Displays the measured Round Trip Time.
        Sorting Functionality:
            Sort by clicking column headers, with appropriate numerical sorting for RTT and IP addresses.
        Appearance:
            Column widths should be dynamically adjusted based on content (e.g., ccTLD fixed width, RTT auto-sized for numeric precision).

    Console Log
        Type: QPlainTextEdit
        Function: Debugging text area for logging actions and messages.
        Expected Messages: Provide feedback such as "Total bridges checked: X" and any errors encountered.

3. Functional Logic

A. Bridge Checking Logic

    Entry Validation: Checks each bridge format before processing.
    Connectivity Check:
        Use sockets to attempt connections to valid bridges and measure RTT.
    Data Collection: Store successful connections and latencies to be displayed in the results table.

B. Filtering Logic

    Country Code Exclusion:
        Remove bridges from the results list that match selected country codes.
    Clone Filtering Logic:
        Sort bridges into groups based on identical subnet octets prior to filtering.
        Implement the rules for clone#:
            For example, for input "clone1":
                Retain only one bridge from each group of the same first octet (e.g., 130.183.*.*).
            For input "clone2":
                Retain only one bridge from each group of the same second octet.
            When multiple filters like clone1, clone2 are active:
                Allow filtering based on predefined rules across different octets.

4. Error Handling

    User Input Validation: Provide user feedback for incorrect bridge formats and filter patterns.
    List Interaction: Ensure attempts to manipulate removed or non-existent table items are safeguarded.

5. User Interaction Enhancements

    Keyboard Shortcuts: Implement Enter key functionality to trigger the Add Filter action.
    Help System: Offer detailed help regarding input formats, valid patterns, and the operational logic for clone filtering.

6. User Interface and Style

    Design Theme: Unified dark theme for the application interface.
    Layout Improvements: Optimize the layout to minimize unnecessary scrollbars and maximize usability.
    Dynamic Column Width Handling: Allow for dynamic resizing based on content to improve overall interface appearance.

7. Copyright Information

    Include copyright notice at the bottom of the application’s help section:
        "Copyright © Mazafakas Development Inc."
1. Application Overview

    Name: Tor Bridge Connectivity Checker
    Goal: Validate connectivity to Tor bridges with advanced filtering mechanisms, including the handling of IP address clones, to improve connection efficiency and output clarity.

2. Components

A. Input Section

    Network Interface Display
        Type: QPlainTextEdit (Read-Only)
        Function: Lists available network interfaces.
        Behavior: Updates automatically upon startup.

    Bridges Input Area
        Type: QPlainTextEdit
        Expected Input Formats:
            Standard: 192.168.0.1:443
            Obfuscated: obfs4 185.117.153.235:80 7365271E0F03600D8566D414F755D04AE8585FCE
        Validation: Checks must occur for valid formatting before submission.

    Check Bridges Button
        Type: QPushButton
        Label: "Check Bridges"
        Function: Starts the connectivity process for entered bridges.
        Behavior: Validates input and asynchronously checks connections.

B. Country Selection Section

    Country Code Buttons
        Type: QPushButton (per country)
        Function: Toggles selection to exclude specific countries from results.
        Behavior: Checked states modify self.selected_countries for filtering.

    Select All / Deselect All Buttons
        Type: QPushButton
        Labels: "Select All" / "Deselect All"
        Behavior: Toggles the check states of all country buttons.

C. Filtering Section

    Pattern Filter Input Field
        Type: QPlainTextEdit
        Placeholder: "Enter filter pattern (e.g., clone# for subnet filtering)."
        Expected Patterns:
            Wildcards: *.example.com
            Subnet Ranges: 192.168.0.1-192.168.0.255 or 192.168.0.0/16
            Clones:
                clone1: Filters based on the first octet.
                clone2: Filters based on the second octet.
                clone3: Filters based on the third octet.
                clone4: Filters based on the fourth octet.
        Validation: Ensures valid patterns are used for input; shows error messages for invalid entries.

    Active Blacklisted Filters List
        Type: QListWidget
        Function: Displays currently active filters.
        Behavior: Allows removal of selected filters.

    Add / Remove Filter Buttons
        Type: QPushButton
        Labels: "Add Filter", "Remove Selected Filter"
        Behavior:
            Add: Takes input from the filter field and adds it to the list.
            Remove: Deletes selected filters.

D. Results Section

    Results Display Table
        Type: QTableWidget
        Columns:
            ccTLD: Character representation of the country code.
            Bridge: The IP address in the format IP:Port.
            RTT (ms): Measured round trip time.
        Sorting Functionality: Allows sorting by clicking column headers with:
            ccTLD: Alphabetical sorting.
            Bridge: Numerical sorting for IP addresses.
            RTT: Numerical sorting for latencies measured.
        Appearance: Columns to resize dynamically based on content, with fixed widths where necessary for ccTLD and RTT.

    Console Log
        Type: QPlainTextEdit
        Function: Displays actions and error messages.
        Messages: Status updates (e.g., "Total bridges checked: X") and error notifications.

3. Functional Logic

A. Bridge Checking Logic

    Input Validation: Validate each entry for expected formats.
    Connection Check:
        Use sockets to check each bridge's connectivity; measure the RTT.
        Store successful responses with their latencies.

B. Filtering Logic

    Country Code Exclusion:
        Identify bridges that match the selected countries and exclude them from the results.

    Clone Logic:
        Identification: Clones are defined as bridges that share the same specific subnet octet position with duplicate IP addresses.
        Filtering Mechanism:
            Action of Cloning:
                For input clone1: Remove duplicates based on the first octet. Example:
                    From: 130.233.193.157, 130.183.6.115 → Keep one such as 130.183.6.115.
                For input clone2: Remove duplicates based on the second octet. Example:
                    From: 210.10.74.98, 210.10.164.57 → Keep one such as 210.10.164.57.
                Continue to clone3, clone4, representing further subnet octets as described above.
        Pre-Filtering and Post-Filtering:
            Before checking, group bridges into their respective clone groups based on filtered patterns; choose one from each group.
            Adjust results dynamically based on user-defined filters.

4. Error Handling

    User Input Validation:
        Clearly log any invalid input specifics to help users correct issues.
    Access and Modification Checks:
        Ensure actions taken on table items verify the existence of those items.

5. User Interaction Enhancements

    Keyboard Shortcuts: Implement Enter key functionality for quick adding of filters.
    Help System: Provide help detailing valid input formats and instructions.

6. User Interface and Design

    Theme: A cohesive dark theme to enhance usability.
    Layout Improvements:
        Enhance spacing for better readability.
        Minimize the need for vertical scroll bars.
### A. Input Section

#### 1. Network Interface Display
- **Type**: Read-Only Text Area (QPlainTextEdit)
- **Function**: Displays available network interfaces.
- **Behavior**: Fetches and updates network interfaces on startup.

#### 2. Bridges Input Area
- **Type**: Multi-Line Text Input (QPlainTextEdit)
- **Expected Formats**:
  - IP and Port: "192.168.0.1:443"
  - Obfuscated Bridge Format: "obfs4 185.117.153.235:80 [key]"
- **Validation**: Ensure each entry follows the acceptable formats before further processing.

#### 3. Check Bridges Button
- **Type**: Push Button (QPushButton)
- **Label**: "Check Bridges"
- **Function**: Initiates bridge connectivity checks.
- **Behavior**: Validates input, processes connections asynchronously, and logs results.

### B. Country Selection Section

#### 1. Country Code Buttons
- **Type**: Push Button (one for each two-character country code)
- **Function**: Allows users to select countries for exclusion from results.
- **Behavior**: Toggles checked state, modifies `self.selected_countries` for filtering.

#### 2. Select All / Deselect All Buttons
- **Type**: Push Button (QPushButton)
- **Labels**: "Select All" / "Deselect All"
- **Behavior**: Manages toggling of all country selection buttons.

### C. Filtering Section

#### 1. Pattern Filter Input Field
- **Type**: Text Input (QPlainTextEdit)
- **Placeholder**: "Enter filter pattern (e.g., clone# for subnet filtering)."
- **Expected Patterns**:
  - Wildcards: "*.example.com"
  - Subnet Ranges: "192.168.0.1-192.168.0.255"
- **Clone Patterns**:
  - **clone1**: Identify and handle the first octet.
  - **clone2**: Identify and handle the second octet.
  - **clone3**: Handle the third octet.
  - **clone4**: Handle the fourth octet.
- **Validation**: Assesses patterns input, providing feedback for invalid formats.

#### 2. Active Blacklisted Filters List
- **Type**: List Widget (QListWidget)
- **Function**: Displays active filters that users define.
- **Behavior**: Allows for the selection and removal of filters.

#### 3. Add / Remove Filter Buttons
- **Type**: Push Button
- **Labels**: "Add Filter" / "Remove Selected Filter"
- **Function**: Manages the filter list for active filters.
- **Behavior**:
  - **Add**: Appends pattern from input field to active filters.
  - **Remove**: Deletes selected filters from the active list.

### D. Results Section

#### 1. Results Display Table
- **Type**: Table Widget (QTableWidget)
- **Columns**:
  - **ccTLD**: Displays two-character country codes.
  - **Bridge**: Shows the bridge string (IP:Port or obfuscated).
  - **RTT (ms)**: Shows round trip time.
- **Sorting Functionality**:
  - Allows sorting by ccTLD, Bridge, and RTT on header click.
  - Ensures proper numerical sorting for IPs and latencies.
- **Column Width Management**: Resize based on content and fixed sizes for clarity.

#### 2. Console Log
- **Type**: Read-Only Text Area (QPlainTextEdit)
- **Function**: Log operational messages and error notifications.
- **Messages**: Status updates and errors.

## 3. Functional Logic

### A. Bridge Checking Logic
- **Input Validation**: Ensure formats are correct before execution.
- **Connection Procedure**:
  - Connect to specified bridges and measure RTT.
  - Gather successful responses including latencies.

### B. Filtering Logic
- **Country Code Exclusion**: Validate against country selections and exclude.
- **Clone Logic**:
  - Clones: Bridges with identical subnet positions based on user-defined clone filters.
  - **Filtering Mechanism**:
    - If `clone1` is active, retain only one instance of bridges with identical first octets.
    - If `clone2` is active, retain only one instance of bridges with identical second octets.
    - Extend to `clone3` and `clone4` for further octets.
    - Filter grouping to organize bridges before further evaluations.
    - Allow only one clone filter at a time but permit multiple different clone filters in the list.

### Examples of Clone Logic
1. **Input Examples**:
   - `clone1`
     - Bridges: 
       - `130.233.193.157`
       - `130.183.6.115` 
     - Result: Keep one random instance from the group.
   - `clone2`
     - Bridges:
       - `210.10.74.98`
       - `210.10.164.57`
     - Result: Keep one random instance from the group.
   - Combined:
     - `clone1`, `clone2` would filter based on both conditions.

## 4. Error Handling
- **User Input Validation**: Provide clear error messages for incorrect patterns and ensure no access to non-existing table indices.

## 5. User Interaction Enhancements
- **Keyboard Shortcuts**: Implement Enter to add filters quickly.
- **Help Functionality**: Contextual help explaining usage.

## 6. User Interface and Design
- **Theme**: Dark theme throughout the application.
- **Layout Improvements**: Minimize scrolling requirements, optimize space.
- **Dynamic Column Adjustments**: Ensure proper visibility and usability.

### A. Input Section

#### 1. Network Interface Display
- **Type**: Read-Only Text Area (QPlainTextEdit)
- **Function**: Displays all available network interfaces on the user's machine such as Ethernet and Wi-Fi connections.
- **Data Retrieval**: Interfaces are dynamically retrieved upon application startup and listed in a non-editable format. 

#### 2. Bridges Input Area
- **Type**: Multi-Line Text Input (QPlainTextEdit)
- **Expected Input Formats**:
  - Standard: `192.168.0.1:443`
  - Obfuscated: `obfs4 185.117.153.235:80 [key]`
- **Validation Mechanisms**:
  - Each bridge entry is validated for formatting errors.
  - Error messages are displayed if any input does not meet defined patterns.

#### 3. Check Bridges Button
- **Type**: Push Button (QPushButton)
- **Label**: "Check Bridges"
- **Function**: Initiates the connectivity check for all entered bridges.
- **Behavior**: 
  - Validates input before proceeding.
  - Executes connection tests asynchronously using a separate thread to avoid UI freezing.
  - Logs results to the console, displaying success or failure notifications for each check.

---

### B. Country Selection Section

#### 1. Country Code Buttons
- **Type**: Push Button (One for each country code)
- **Function**: User-selectable buttons for excluding specific countries from results based on their geolocation.
- **Expected Labels**: Two-character country codes (e.g., `US`, `CA`, `DE`).
- **Behavior**:
  - Each button toggles its state (checked/unchecked).
  - Maintains an updated list of selected countries in `self.selected_countries`.

#### 2. Select All / Deselect All Buttons
- **Type**: Push Button (QPushButton)
- **Labels**: "Select All" / "Deselect All"
- **Behavior**: Toggles the check state of all country buttons in one operation.

---

### C. Filtering Section

#### 1. Pattern Filter Input Field
- **Type**: Text Input (QPlainTextEdit)
- **Placeholder Text**: "Enter filter pattern (e.g., clone# for subnet filtering)."
- **Expected Patterns**:
  - Wildcards: `*.example.com` (matches any subdomain)
  - Subnet Ranges: `192.168.0.1-192.168.0.255`
  - Cloning Logic:
    - **`cloneX`** (where `X` is the octet position to filter):
      - **`clone1`**: Identifies and retains one bridge from IPs sharing the same first octet.
      - **`clone2`**: Identifies and retains one bridge based on the second octet.
      - Similar logic extends for `clone3` and `clone4`.
- **Validation**: Ensures that only valid patterns are accepted and provides feedback on erroneous ones.

#### 2. Active Blacklisted Filters List
- **Type**: List Widget (QListWidget)
- **Function**: Displays user-defined filters currently active for the session.
- **Behavior**: Users can select and remove filters from the active list.

#### 3. Add / Remove Filter Buttons
- **Type**: Push Button
- **Labels**: "Add Filter", "Remove Selected Filter"
- **Functionality**:
  - **Add Filter**: Takes the pattern string from the filter input field and appends it to the active filters list.
  - **Remove Selected Filter**: Removes the currently selected filter(s).

---

### D. Results Section

#### 1. Results Display Table
- **Type**: Table Widget (QTableWidget)
- **Columns**: 
  - **ccTLD**: Two-character representation of the country code.
  - **Bridge**: The full bridge string as entered (IP:Port or obfuscated).
  - **RTT (ms)**: The measured round trip time.
- **Sorting Capabilities**:
  - Allows sorting by clicking on the header of each column, enabling:
    - **ccTLD**: Alphabetic sorting (A-Z).
    - **Bridge**: Numeric sorting for IP addresses.
    - **RTT**: Numeric sorting for latencies measured.
- **Appearance**:
  - Columns should automatically resize based on content while maintaining fixed widths where necessary.

#### 2. Console Log
- **Type**: Read-Only Text Area (QPlainTextEdit)
- **Function**: Displays logs of actions, results, and error messages.
- **Message Examples**: 
  - "Total bridges checked: X."
  - "Filtered to [value]."
- **Behavior**: Continuously appends new messages based on user actions.

---

## 3. Functional Logic

### A. Bridge Checking Logic
- **Input Validation**: Each bridge entry validated before execution to ensure formats are correct.
- **Connection Procedure**:
  - Use sockets to connect to each bridge and measure the RTT.
  - Store results (success/failure) in a structured format for displaying connections.
  
### B. Filtering Logic

1. **Country Code Exclusion**:
   - Applies upon initiating the check or post-filtering to remove any IPs corresponding to the selected country codes.

2. **Clone Logic**:
   - Clones are defined as bridges with identical octets based on user-defined patterns in the filters.
   - **Filtering Mechanism**:
     - Identify groups of IPs sharing the same defined octet:
       - For user input `clone1`, system retains only a single bridge from the group sharing the same first octet.
       - For input `clone2`, only maintains one bridge from the group sharing the same second octet.
     - **Example Logic**:
       - Input: `clone1`
         - Given Bridges: `130.233.193.157, 130.183.6.115`
         - Result: Retain one random instance (e.g., `130.183.6.115`).
       - Input: `clone2`
         - Given Bridges: `210.10.74.98, 210.10.164.57`
         - Result: Retain one random instance (e.g., `210.10.164.57`).
     - If multiple filters (e.g., `clone1`, `clone2`) are present, filter according to all criteria:
       - Apply pre-filtering to organize bridges into groups based on octets, then apply user-defined clone filtering patterns iteratively.

---

## 4. Error Handling
- **User Input Validation**:
  - Provide clear feedback for any invalid inputs or connection failures.
  - Ensure that non-existing or filtered entries do not trigger errors during operations.

---

## 5. User Interaction Enhancements
- **Keyboard Shortcuts**:
  - Allow pressing Enter to quickly add patterns to the filter list.
- **Help Button**:
  - Offers detailed guidance on using the application effectively, explaining valid input patterns and functionalities.
  
---

## 6. User Interface and Design
- **Visual Theme**: A unified dark theme throughout the application for improved usability.
- **Layout Management**:
  - Optimize the layout to remove unnecessary vertical scroll bars and maximize space efficiency.
  - Ensure that user interfaces are intuitive and visually coherent.


### A. Input Section
- **Network Interface Display**: This read-only text area lists all the network interfaces available on a user's machine. When an application starts, it automatically retrieves and presents these interfaces—creating a user-friendly means of selecting their preferred network path for connectivity checks.
  
- **Bridges Input Area**: Users are able to input multiple lines of text representing different Tor bridges. The application validates the syntax of each bridge entry to ensure that it adheres to defined formats (both standard and obfuscated). This step is crucial as improperly formatted entries could lead to connection failures or misleading results.
  
- **Check Bridges Button**: When clicked, this button triggers an asynchronous process to validate and connect to the entered bridges. It ensures that the application's interface remains responsive while conducting potentially time-consuming connection tests.

### B. Country Selection Section
- **Country Code Buttons**: Representing various countries, these buttons allow users to select or exclude specific countries whose bridges they do not wish to connect through. This functionality is critical for users seeking to maintain compliance with geographical restrictions or avoid specific networks.
  
- **Select All / Deselect All Buttons**: These buttons enhance usability, allowing users to toggle between selecting all countries or clearing all selections in one action, saving time and clicks.

### C. Filtering Section
- **Pattern Filter Input Field**: This area receives user-defined patterns that determine which bridges to keep or exclude based on specified criteria. It supports various inputs, including wildcards, subnet ranges, and defined clone filters that specify IP address handling rules. The flexibility in this section supports a wide range of user needs and preferences.

- **Active Blacklisted Filters List**: This list dynamically displays active filters that the user has chosen to apply to the bridge checks. Users can track their filtering actions and remove any that are no longer relevant.

### D. Results Section
- **Results Display Table**: The application organizes results into a clear, structured table that allows users to see the outcome of their checks concisely. It enables sorting by various metrics, such as country codes, RTT values, or the bridge IPs themselves, allowing users to quickly assess which bridges are effective or problematic.
  
- **Console Log**: A dedicated area for outputting status messages and errors encountered during operations. It acts as the application's feedback mechanism, providing real-time information to the user regarding successful connections, filtered results, and any encountered issues.

---

## 3. Functional Logic

### A. Bridge Checking Logic
- This core component handles the connection process to the listed bridges. Given the potential variability in network conditions, the process must be robust. The application should:
  - Validate each bridge entry meticulously, ensuring conformity to valid syntax before attempting connections.
  - Connect to each valid bridge address asynchronously, measuring RTT for successful connections.
  - Log the outcomes, informing users about successful or failed connectivity attempts, while also capturing the latency involved in successful attempts.

### B. Filtering Logic
- The filtering logic is instrumental in ensuring that redundant clones are not included in the connectivity checks. The approach is defined as follows:
  - **Identification of Clones**: Clones are determined based on IPs sharing identical specific subnet positions defined by the user's input patterns (e.g., `clone1`, `clone2`).
  - **Implementation of Clone Filters**:
    - For `clone1`, the application removes duplicates based on the first octet. For instance, from a list of IPs sharing the same first octet, only one is retained.
    - Extending this logic, `clone2` retains one instance based on the second octet, `clone3` for the third, and `clone4` for the fourth octet.

- **Dynamic Filtering**:
  - Pre-Filtering: Before the connectivity checks occur, the application groups bridges by their octets according to the filters set by the user. This grouping facilitates the removal of duplicates while retaining necessary variations.
  - Post-Filtering: After the connectivity checks, the results are again filtered based on current user-defined filters, ensuring that the displayed results are both relevant and streamlined.

---

## 4. Error Handling & User Interaction
- The application must include robust error handling mechanisms to prevent user frustration and improve overall experience. Key aspects include:
  - Clear user prompts for validation failures, including specified formats for input.
  - Logs should note when an error occurs, detailing the specific bridge(s) or filter(s) that led to the issue.
  - Allow for keyboard shortcuts to expedite user actions, such as adding filters or checking bridges.

---

## 5. UI/UX Considerations
- The design should foster an efficient workflow:
  - A unified dark theme enhances visual appeal and user comfort over extended use.
  - The layout must be intuitive, minimizing the number of clicks required for frequently performed actions, such as filtering or checking bridges.
  - Dynamic resizing of segments (like the results table) must accommodate various content lengths and types, ensuring no crucial information is hidden or truncated.



clone1:

Designed to filter on the first octet of the IP addresses.
Retains only one representative IP address from any group of IPs that shares the same first octet.
For instance, given the bridges 255.254.253.252, 255.253.252.251, and 255.252.251.250, the filter would allow only 255.254.253.252, 255.253.252.251, and 255.252.251.250 to remain.

because 255 = first subnet octet, everything after = other clones types in logic.

clone1 = we are considering strictly only the first subnet octet, not any ranges which following before and after (assuming that there no any subnet octets before first one).
clone2 = we are considering strictly only the second subnet octet, not any ranges which following before and after.
clone3 = we are considering strictly only the third subnet octet, not any ranges which following before and after.
clone4 = we are considering strictly only the fourth subnet octet, not any ranges which following before and after (assuming that there no any subnet octets after fourth one).

Thank you for clarifying the clone logic with precise definitions. Here’s a refined and expanded conceptual tech schematic that accurately reflects the way cloning logic should function based on your input, ensuring that it maintains clarity and alignment with the specifications you provided.
Detailed Tech Conceptual Schematic: Tor Bridge Connectivity Checker

# Tech Conceptual Schematic: Tor Bridge Connectivity Checker

## 1. Application Overview
- **Name**: Tor Bridge Connectivity Checker
- **Objective**: To validate connectivity to Tor bridges and efficiently filter out duplicate IP addresses (clones) based on their subnet octet structure, ensuring streamlined and effective connectivity management.

---

## 2. Functional Components

### A. Input Section

1. **Network Interface Display**
   - **Type**: Read-Only Text Area (QPlainTextEdit)
   - **Functionality**: Displays available network interfaces for user selection, ensuring that users connect through the correct interface based on their system's configuration.

2. **Bridges Input Area**
   - **Type**: QPlainTextEdit
   - **Expected Formats**: Users enter lists of bridge addresses in specified formats (e.g., `192.168.0.1:443`, `obfs4 185.117.153.235:80 [key]`).
   - **Validation**: Checks input for formatting errors, providing immediate feedback for correction.

3. **Check Bridges Button**
   - **Label**: "Check Bridges"
   - **Function**: Initiates connectivity checks for the listed bridges, executing asynchronously for performance efficiency.

---

### B. Country Selection Section

1. **Country Code Buttons**
   - **Type**: QPushButton for each country code
   - **Function**: Allow users to exclude specific countries from the connectivity results.
   - **Behavior**: Toggles selection state, impacting which results are displayed based on geographic filtering preferences.

2. **Select All / Deselect All Buttons**
   - **Functionality**: These buttons enable users to manage country selections quickly, facilitating ease of use.

---

### C. Filtering Mechanism

1. **Pattern Filter Input Field**
   - **Type**: QPlainTextEdit
   - **Placeholder Text**: "Enter filter pattern (e.g., clone# for subnet filtering)."
   - **Expected Input Patterns**:
     - Wildcards (e.g., `*.example.com`)
     - Subnet ranges (e.g., `192.168.0.1-192.168.0.255`)
     - Clone filters:
       - **`clone1`**: Focuses on the first octet.
       - **`clone2`**: Focuses on the second octet.
       - **`clone3`**: Focuses on the third octet.
       - **`clone4`**: Focuses on the fourth octet.
   - **Validation**: Ensuring patrons input correct information, while also providing manageable error notifications if invalid.

2. **Active Blacklisted Filters List**
   - **Function**: Displays all user-defined filters currently applied, allowing easy management.

3. **Add / Remove Filter Buttons**
   - **Behavior**: 
     - **Add Filter**: Includes the current input pattern in the list of active filters.
     - **Remove Selected Filter**: Eliminates the chosen filter(s) from the active list.

---

### D. Results Section

1. **Results Display Table**
   - **Type**: QTableWidget
   - **Columns**:
     - **ccTLD**: Two-character country code.
     - **Bridge**: Complete representation of each bridge.
     - **RTT (ms)**: Round Trip Time measured milliseconds.
   - **Sorting Functionality**: Allows sorting of results by clicking headings, managing data based on user needs.

2. **Console Log**
   - **Type**: QPlainTextEdit (Read-Only)
   - **Function**: Displays operational messages and results logging as connectivity tests occur.

---

## 3. Operational Logic

### A. Bridge Checking Logic
- **Input Validation**: Each bridge entry is validated for proper formatting before proceeding with connectivity checks.
- **Execution**: Each valid bridge is checked asynchronously to gather metrics about RTT and connectivity success.

### B. Filtering Logic

1. **Country Code Exclusion**: 
   - Bridges associated with selected countries are excluded from results dynamically as filters are applied.

2. **Cloning Logic**:
   - **Definition**: Clones are bridges that share an identical first, second, third, or fourth octet based on user-defined filtering patterns.
   - **Execution of Clone Logic**:
     - **clone1**: Filters strictly on the first octet. For example:
       - Given: `255.254.253.252`, `255.253.252.251`, `255.252.251.250`
       - Retains: All share the octet value `255` at the first position.
     - **clone2**: Focuses on the second octet. For example:
       - Given: `192.255.0.1`, `192.255.1.1`, `192.168.2.1`
       - Retains: One from the group sharing the second octet `255`, disregarding differing third or fourth octets.
     - **clone3**: Concentrates on the third octet, retaining one bridge that shares the same value while disregarding the rest.
     - **clone4**: Operates similarly for the fourth octet where only one instance is kept.
   - **Dynamic Filtering Process**: Allows integration of multiple clone filters, processing input and waiting to execute before any checking occurs, which ensures orderly outcomes.

---

## 4. User Interaction Enhancements
- **Keyboard Shortcuts**: Implement shortcuts for faster interaction, ensuring tools for adding filters or checking bridges can be accessed swiftly.
- **Help System**: Easily accessible help dialogues that assist users in understanding how to input data and define filters effectively.

---

## 5. Usability Features 
- **Visual Design**: Represents a dark theme throughout the application to improve user experience, particularly during extended use.
- **Layout Considerations**: Component arrangements prioritize usability by minimizing the necessity for scrolling and ensuring clarity in user interactions.

---

## 6. Documentation and Licensing
- **User Manual**: Embedded help documentation detailing how to utilize the application, manage input, and troubleshoot issues effectively.
- **Copyright Statement**: Clearly states ownership and rights to the application code.
- **Notice**: "Copyright © Mazafakas Development Inc."

---

## 7. Advanced Functional Considerations
- **Performance Metrics**: Log essential performance measures such as average RTT and bridge reliability statistics to improve user understanding and assist optimization efforts.
- **Preference Saving**: Implement functionality to save user session settings for future use, including country selections and active filters.

---

## 8. Error Handling Strategy
- **Proactive User Feedback**: Provide meaningful guidance for correcting inputs and communicate clearly about any operational issues.
- **Data Integrity**: Ensure that attempts to interact with filtered or previously existing entries do not result in errors or crashes.

---

This more conceptually expanded view emphasizes the logic behind the application's operation, particularly the intricacies of the cloning logic and its implications for bridge connectivity checks. It reflects the specific requirements you've provided while ensuring clarity and coherence. If you need more adjustments or specific areas further expanded, feel free to ask!

so, you see the logic now?

you simply selecting with tags "clone1, clone2, clone3, clone4" which specific octetes to filter in combination.

this approach is more fluid in concept and allows to filter only though first and fourh octet, for example.

Yes, I understand the logic better now. The filtering approach allows for the selection of specific octets (first, second, third, fourth) independently using tags like "clone1," "clone2," "clone3," and "clone4." This gives users flexibility in determining which parts of the IP address they want to filter out, while also enabling them to combine these filters to achieve tailored results.
Key Aspects of the Enhanced Clone Logic

    Fluidity and Functionality:
        Users can apply multiple filters simultaneously or independently, allowing them to manage IP addresses effectively.
        For instance, a user can choose to filter by the first octet only with "clone1" while also deciding to filter only by the fourth octet with "clone4." This capability allows for very specific control over which bridges are retained or excluded in the results.

    Combination of Filters:
        The flexibility of the system means users can craft a nuanced filtering strategy. For example:
            Using "clone1" and "clone3" together would mean keeping one bridge from every unique first octet and one bridge from every third octet grouping.
            This combination allows scenarios where certain IP structures are preserved based on the user’s operational requirements.

    Pre-Filtering and Post-Filtering:
        The logic involves grouping entries before connectivity checks based on user-defined octet preferences, eliminating duplicates before any connection attempts are made, thus optimizing performance.
        Post-checking filtering re-evaluates the results against the active clone filters and geographic exclusions, refining the list shown to the user.









```

import sys
import json
import re
import socket
import time
import netifaces
from PyQt5.QtWidgets import (
    QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel,
    QPushButton, QPlainTextEdit, QComboBox, QListWidget, QScrollArea,
    QTableWidget, QTableWidgetItem, QToolButton, QMessageBox
)
from PyQt5.QtCore import Qt, QThread, pyqtSignal


class BridgeChecker(QWidget):
    CONFIG_FILE = "bridges.cfg"
    GEOIP_FILE = "geoip"

    def __init__(self):
        super().__init__()
        self.geoip_data = self.load_geoip_data()
        self.country_buttons = {}
        self.selected_countries = set()
        self.initUI()
        self.load_settings()

        self.previous_results = []
        self.all_results = {}

    def load_geoip_data(self):
        geoip_ranges = {}
        try:
            with open(self.GEOIP_FILE, 'r') as f:
                for line in f:
                    line = line.strip()
                    if line and not line.startswith('#'):
                        parts = line.split(',')
                        country_code = parts[2][:2]
                        if country_code not in geoip_ranges:
                            geoip_ranges[country_code] = []
                        geoip_ranges[country_code].append((int(parts[0]), int(parts[1])))
        except IOError:
            print("Error: GeoIP file not found.")
        return geoip_ranges

    def initUI(self):
        self.setWindowTitle('Tor Bridge Connectivity Checker')
        main_layout = QVBoxLayout(self)

        # Network Interface Section
        iface_layout = QHBoxLayout()
        iface_label = QLabel("Network Interface:")
        self.iface_selector = QComboBox(self)
        interfaces, _ = self.get_network_interfaces()
        self.iface_selector.addItems(interfaces)
        iface_layout.addWidget(iface_label)
        iface_layout.addWidget(self.iface_selector)
        main_layout.addLayout(iface_layout)

        # Bridges Input Section
        bridge_input_label = QLabel("Bridges to Check:")
        self.bridge_input = QPlainTextEdit(self)
        main_layout.addWidget(bridge_input_label)
        main_layout.addWidget(self.bridge_input)

        check_button = QPushButton('Check Bridges', self)
        check_button.clicked.connect(self.start_bridge_check)
        main_layout.addWidget(check_button)

        # Country Exclusion Section
        filter_country_label = QLabel("Select Countries to Exclude:")
        main_layout.addWidget(filter_country_label)

        country_button_layout = QHBoxLayout()
        for country_code in sorted(self.geoip_data.keys()):
            button = QPushButton(country_code)
            button.setFixedSize(30, 30)
            button.setCheckable(True)
            button.setStyleSheet("background-color: #1c1c1c; color: #ffffff;")
            button.clicked.connect(lambda checked, code=country_code: self.toggle_country_selection(code, checked))
            self.country_buttons[country_code] = button
            country_button_layout.addWidget(button)

        # Adding Select All and Deselect All buttons
        select_all_button = QPushButton('Select All', self)
        select_all_button.clicked.connect(self.select_all_countries)
        country_button_layout.addWidget(select_all_button)

        deselect_all_button = QPushButton('Deselect All', self)
        deselect_all_button.clicked.connect(self.deselect_all_countries)
        country_button_layout.addWidget(deselect_all_button)

        # Adding Scroll Area for country buttons
        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        country_widget = QWidget()
        country_widget.setLayout(country_button_layout)
        scroll_area.setWidget(country_widget)
        main_layout.addWidget(scroll_area)

        # Filtering Input and Buttons Section
        filter_layout = QHBoxLayout()

        self.first_octet_input = QPlainTextEdit(self)
        self.first_octet_input.setPlaceholderText("Enter clone# or filter (e.g., 192.168.0.1-192.168.0.255, or 192.168.0.0/16)")
        self.first_octet_input.setMaximumHeight(30)
        filter_layout.addWidget(self.first_octet_input)

        add_filter_button = QPushButton('Add', self)
        add_filter_button.clicked.connect(self.add_filter)
        filter_layout.addWidget(add_filter_button)

        remove_filter_button = QPushButton('Remove', self)
        remove_filter_button.clicked.connect(self.remove_filter)
        filter_layout.addWidget(remove_filter_button)

        help_button = QToolButton(self)
        help_button.setText("?")
        help_button.setStyleSheet("background-color: #007ACC; color: white;")
        help_button.clicked.connect(self.show_help)
        filter_layout.addWidget(help_button)

        main_layout.addLayout(filter_layout)

        # Active Filters List
        self.active_filters_list = QListWidget(self)
        main_layout.addWidget(QLabel("Filters:"))
        main_layout.addWidget(self.active_filters_list)

        # Results Section
        self.results_label = QLabel("Results:")
        main_layout.addWidget(self.results_label)

        self.results_table = QTableWidget(self)
        self.results_table.setColumnCount(3)
        self.results_table.setHorizontalHeaderLabels(['ccTLD', 'RTT (ms)', 'Bridge'])
        self.results_table.setColumnWidth(0, 100)
        self.results_table.setColumnWidth(1, 100)
        self.results_table.setColumnWidth(2, 250)
        self.results_table.horizontalHeader().setStretchLastSection(True)
        self.results_table.horizontalHeader().setSectionsClickable(True)
        self.results_table.horizontalHeader().sectionClicked.connect(self.sort_results)
        main_layout.addWidget(self.results_table)

        filter_results_button = QPushButton('Filter Results', self)
        filter_results_button.clicked.connect(self.filter_results)
        main_layout.addWidget(filter_results_button)

        copy_all_button = QPushButton('Copy All', self)
        copy_all_button.clicked.connect(self.copy_all_to_clipboard)
        main_layout.addWidget(copy_all_button)

        # Console Log Section
        console_label = QLabel("Console Log:")
        self.console_display = QPlainTextEdit(self)
        self.console_display.setReadOnly(True)
        self.console_display.setStyleSheet("background-color: black; color: white;")
        main_layout.addWidget(console_label)
        main_layout.addWidget(self.console_display)

        # Global Style Settings
        self.setStyleSheet("""
            QWidget {
                background-color: #121212;
                color: #E0E0E0;
            }
            QPlainTextEdit, QListWidget, QTableWidget {
                background-color: #1E1E1E;
                color: #FFFFFF;
            }
            QPushButton {
                background-color: #333333;
                border: 1px solid #666666;
                color: #E0E0E0;
            }
            QPushButton:hover {
                background-color: #555555;
            }
            QPushButton:pressed {
                background-color: #777777;
            }
            QTableWidget::item {
                background-color: #1E1E1E;
            }
            QPushButton:checked {
                background-color: #007ACC;
                color: #FFFFFF;
            }
        """)

    def deselect_all_countries(self):
        for button in self.country_buttons.values():
            button.setChecked(False)
            button.setStyleSheet("background-color: #1c1c1c; color: #ffffff;")
        self.selected_countries.clear()

    def select_all_countries(self):
        for button in self.country_buttons.values():
            button.setChecked(True)
            button.setStyleSheet("background-color: #007ACC; color: #ffffff;")
            self.selected_countries.add(button.text())

    def toggle_country_selection(self, country_code, checked):
        button = self.country_buttons[country_code]
        if checked:
            button.setStyleSheet("background-color: #007ACC; color: #ffffff;")
            self.selected_countries.add(country_code)
        else:
            button.setStyleSheet("background-color: #1c1c1c; color: #ffffff;")
            self.selected_countries.remove(country_code)

    def get_network_interfaces(self):
        interfaces = netifaces.interfaces()
        try:
            default_gateway = netifaces.gateways()['default'][netifaces.AF_INET][1]
        except (KeyError, TypeError):
            default_gateway = interfaces[0] if interfaces else ''
        return interfaces, default_gateway

    def update_console(self, message):
        self.console_display.appendPlainText(message)

    def start_bridge_check(self):
        raw_bridge_data = self.bridge_input.toPlainText()
        cleaned_bridge_data = self.clean_input_bridge_data(raw_bridge_data)

        if not cleaned_bridge_data.strip():
            self.update_console("No bridges to check.")
            return

        total_bridges = len(cleaned_bridge_data.splitlines())
        self.update_console(f"Total bridges entered: {total_bridges}")

        omitted_bridges = self.get_omitted_bridges(cleaned_bridge_data)

        if len(omitted_bridges) == 0:
            self.update_console("No bridges available to check after filtering.")
            return

        self.update_console("Starting the bridge connectivity check...")
        
        self.worker = BridgeCheckWorker(parent=self)
        self.worker.setBridgeData(omitted_bridges)
        self.worker.resultReady.connect(self.display_results)
        self.worker.consoleUpdate.connect(self.update_console)
        self.worker.start()

    def clean_input_bridge_data(self, bridge_data):
        clean_data = re.sub(r'\s+\d+(\.\d+)?\s*ms', '', bridge_data)
        return clean_data.strip()

    def get_omitted_bridges(self, cleaned_bridge_data):
        filters = [item.text() for item in self.active_filters_list.findItems("*", Qt.MatchWildcard)]
        omitted = {}

        for bridge in cleaned_bridge_data.splitlines():
            if not any(self.does_bridge_match_filter(bridge, f) for f in filters) and not self.is_country_excluded(bridge):
                subnet_key = ".".join(bridge.split('.')[:2])  
                if subnet_key not in omitted:
                    omitted[subnet_key] = bridge  

        final_results = list(omitted.values())
        self.update_console(f"Omitted {len(cleaned_bridge_data.splitlines()) - len(final_results)} bridges.")
        return "\n".join(final_results)

    def is_country_excluded(self, bridge):
        ip_port_match = re.search(r'(\d{1,3})\.(\d+)\.(\d+)\.(\d+)', bridge)
        if ip_port_match:
            ip_str = ip_port_match.group(0)
            ip_int = self.ip_to_int(ip_str)
            country_code_found = self.check_ip_in_geoip(ip_int)
            return country_code_found in self.selected_countries
        return False

    def does_bridge_match_filter(self, bridge, filter_pattern):
        filter_pattern = filter_pattern.replace('*', '.*')
        return re.search(filter_pattern, bridge) is not None

    def ip_to_int(self, ip):
        return sum(int(octet) << (8 * (3 - i)) for i, octet in enumerate(ip.split('.')))

    def check_ip_in_geoip(self, ip_int):
        for country_code, ranges in self.geoip_data.items():
            for start, end in ranges:
                if start <= ip_int <= end:
                    return country_code
        return None

    def load_settings(self):
        try:
            with open(self.CONFIG_FILE, 'r') as f:
                config = json.load(f)
                self.bridge_input.setPlainText(config.get('bridge_input', ''))
                filters = config.get('filters', [])
                self.active_filters_list.clear()
                self.active_filters_list.addItems(filters)
                self.selected_countries = set(config.get('selected_countries', []))
                for country_code, button in self.country_buttons.items():
                    if country_code in self.selected_countries:
                        button.setChecked(True)
                        button.setStyleSheet("background-color: #007ACC; color: #ffffff;")
        except FileNotFoundError:
            self.update_console("No configuration file found. Starting with default settings.")

    def save_settings(self):
        config = {
            'bridge_input': self.bridge_input.toPlainText(),
            'filters': [self.active_filters_list.item(i).text() for i in range(self.active_filters_list.count())],
            'selected_countries': list(self.selected_countries)
        }
        with open(self.CONFIG_FILE, 'w') as f:
            json.dump(config, f)

    def add_filter(self):
        octet_pattern = self.first_octet_input.toPlainText().strip()
        if self.is_valid_ip_pattern(octet_pattern):
            existing_filters = [item.text() for item in self.active_filters_list.findItems("*", Qt.MatchWildcard)]
            if octet_pattern in existing_filters:
                self.update_console(f"The filter '{octet_pattern}' is already present.")
                return

            self.active_filters_list.addItem(octet_pattern)
            self.first_octet_input.clear()
            self.save_settings()
        else:
            self.update_console("Invalid pattern. Please use a valid format.")

    def is_valid_ip_pattern(self, pattern):
        # This regex checks for valid IPs, ranges and CIDR notation
        range_regex = r'^(?:\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}-\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$'
        cidr_regex = r'^(?:\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/\d{1,2})$'
        wildcard_regex = r'^(?:\d{1,3}\.\*\.\*\.\*)$'
        clone_regex = r'^clone[1-4]$'  # Adjust this if you want more clone types

        return (
            re.match(range_regex, pattern) or
            re.match(cidr_regex, pattern) or
            re.match(wildcard_regex, pattern) or
            re.match(clone_regex, pattern)
        ) is not None

    def remove_filter(self):
        selected_items = self.active_filters_list.selectedItems()
        if not selected_items:
            self.update_console("No filter selected to remove.")
            return
        for item in selected_items:
            self.active_filters_list.takeItem(self.active_filters_list.row(item))
        self.save_settings()

    def display_results(self, sorted_bridges):
        self.results_table.clear()
        self.results_table.setRowCount(0)
        self.all_results.clear()

        for bridge, latency in sorted_bridges:
            ip_port_match = re.search(r'(\d{1,3}(?:\.\d{1,3}){3}):(\d+)', bridge)
            country_code = None

            if ip_port_match:
                ip = ip_port_match.group(1)
                ip_int = self.ip_to_int(ip)
                country_code = self.check_ip_in_geoip(ip_int)

            row_position = self.results_table.rowCount()
            self.results_table.insertRow(row_position)
            self.results_table.setItem(row_position, 0, QTableWidgetItem(country_code or "Unknown"))
            self.results_table.setItem(row_position, 1, QTableWidgetItem(f"{int(latency)}" if latency is not None else "N/A"))
            self.results_table.setItem(row_position, 2, QTableWidgetItem(bridge))

            self.all_results[bridge] = (country_code, latency)

        self.results_table.setHorizontalHeaderLabels(['ccTLD', 'RTT (ms)', 'Bridge'])
        self.results_table.resizeColumnsToContents()

        self.previous_results = list(sorted_bridges)
        self.update_console(f"Total bridges checked: {len(sorted_bridges)}.")

    def filter_results(self):
        if not self.all_results:
            self.update_console("No previous results to filter.")
            return

        filters = [item.text() for item in self.active_filters_list.findItems("*", Qt.MatchWildcard)]
        filtered_results = []

        for bridge, (country_code, latency) in self.all_results.items():
            if not any(self.does_bridge_match_filter(bridge, f) for f in filters) and country_code not in self.selected_countries:
                filtered_results.append((bridge, latency))

        self.results_table.clear()
        self.results_table.setRowCount(0)

        for bridge, latency in filtered_results:
            ip_port_match = re.search(r'(\d{1,3}(?:\.\d{1,3}){3}):(\d+)', bridge)
            country_code = None

            if ip_port_match:
                ip = ip_port_match.group(1)
                ip_int = self.ip_to_int(ip)
                country_code = self.check_ip_in_geoip(ip_int)

            row_position = self.results_table.rowCount()
            self.results_table.insertRow(row_position)
            self.results_table.setItem(row_position, 0, QTableWidgetItem(country_code or "Unknown"))
            self.results_table.setItem(row_position, 1, QTableWidgetItem(f"{int(latency)}" if latency is not None else "N/A"))
            self.results_table.setItem(row_position, 2, QTableWidgetItem(bridge))

        self.results_table.setHorizontalHeaderLabels(['ccTLD', 'RTT (ms)', 'Bridge'])
        self.results_table.resizeColumnsToContents()
        self.update_console(f"Filtered to {len(filtered_results)} results.")

    def copy_all_to_clipboard(self):
        clipboard_text = []
        for row in range(self.results_table.rowCount()):
            clipboard_text.append(self.results_table.item(row, 2).text())
        clipboard = QApplication.clipboard()
        clipboard.setText("\n".join(clipboard_text))

    def sort_results(self, column):
        self.results_table.sortItems(column, Qt.AscendingOrder)

    def show_help(self):
        QMessageBox.information(self, "Filter Help",
                                "You can use various patterns to filter the bridges:\n"
                                "- Wildcards: '*'\n"
                                "- Valid filters include:\n"
                                "- 'clone1' (first octet)\n"
                                "- 'clone2' (second octet)\n"
                                "- 'clone3' (third octet)\n"
                                "- 'clone4' (fourth octet)\n"
                                "- '192.168.0.1-192.168.0.255'\n"
                                "- '192.168.0.0/16'\n"
                                "\nDeveloped by Mazafakas Development Inc.")

class BridgeCheckWorker(QThread):
    resultReady = pyqtSignal(list)
    consoleUpdate = pyqtSignal(str)

    def __init__(self, parent=None):
        super().__init__(parent)
        self.bridge_data = ""

    def setBridgeData(self, bridge_data):
        self.bridge_data = bridge_data

    def run(self):
        responsive_bridges = self.process_bridges(self.bridge_data)
        sorted_bridges = sorted(responsive_bridges.items(), key=lambda x: x[1])
        self.resultReady.emit(sorted_bridges)

    def process_bridges(self, bridge_data):
        bridge_strings = self.extract_bridges(bridge_data)
        responsive_bridges = {}
        for bridge_string in bridge_strings:
            ip_port_match = re.search(r'(\d{1,3}(?:\.\d{1,3}){3}):(\d+)', bridge_string)
            if ip_port_match:
                ip = ip_port_match.group(1)
                port = int(ip_port_match.group(2))
                success, latency = self.check_ip_port(ip, port, 3.0)
                if success:
                    responsive_bridges[bridge_string] = latency
        return responsive_bridges

    def extract_bridges(self, bridge_data):
        pattern = re.compile(
            r'(?:(\d{1,3}(?:\.\d{1,3}){3}:\d+\s+[A-F0-9]{40})|'
            r'(obfs4\s+\d{1,3}(?:\.\d{1,3}){3}:\d+\s+[A-F0-9]{40}\s+cert=[A-Za-z0-9+/=]+\s+iat-mode=\d+))',
            re.MULTILINE
        )
        matches = pattern.findall(bridge_data)
        return [''.join(filter(None, match)) for match in matches]

    def check_ip_port(self, ip, port, timeout):
        start_time = time.perf_counter()
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        sock.settimeout(timeout)
        try:
            sock.connect((ip, port))
            end_time = time.perf_counter()
            latency = (end_time - start_time) * 1000
            self.consoleUpdate.emit(f"Checking {ip}:{port}… Success")
            return True, latency
        except socket.error:
            self.consoleUpdate.emit(f"Checking {ip}:{port}… Failed")
            return False, None
        finally:
            sock.close()


if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = BridgeChecker()
    ex.show()
    sys.exit(app.exec_())


```

need to fix that by byte filterings (eg /8/16/24/32) because it fuckeying do not workings!

any ideas? just outshow ideas without codes in chats. just comprehend which is malfunctioning in the current code and should be corrected.

just comprehend which is malfunctioning in the current code and should be corrected.

comprehend overally to everything which is malfunctioning in the current code and should be corrected.

"Filtering is likely"
"likely"

why so obscure in words if all the code precisely there?

not sure but it also ignores by range filter as well.

also, consider the fact of PRE/POST filtering/sorting procedures.


and the fuk it should mean?:

Traceback (most recent call last):
  File ".py", line 484, in run
    responsive_bridges = self.process_bridges(self.bridge_data)
                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File ".py", line 489, in process_bridges
    bridge_strings = self.extract_bridges(bridge_data)
                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File ".py", line 507, in extract_bridges
    matches = pattern.findall(bridge_data)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: expected string or bytes-like object, got 'list'
Aborted


now go outshow all fixed approx as original 500 lines code. but with all proper filtering logic, it should be near 700 lines in code. do not try to trick me here mazafaka!

```



then doubtly maybe clone logics interferings somehow at PRE-filtering before checkings if 66.0.0.0/8 does not filering anything "PRE/POST-process"?

clone logic should be applied as explained in all previous texts.
also, all other filtering methods should be PRE/POST-processingly filter-out unneed bridges from checkings and from the result list as: by range filter and by byte filter.

need strictly only huge implemented one code without any errors.

the same.

it seems clonelogic interfering.

because we are leaving only one random clone instance in bridge, which may affect all the rest filtering logic.

need to do that clone logic be independent from other, and if not presenting in filter list, then not act anyhow and mess with filtering logic.

think without codes how to do it all right and to the point.

okay. redo all full code properly as it should be in all orders and PRE/POST separate logics if presenting in filter list exclusively.

do not forget that clone logic is important and should be properly implemented but act somehow independently from everything else, but act.