import subprocess

import json

import os

def get_video_bitrate_and_resolution(file_path):

    """

    Extract video bitrate and resolution using ffprobe

    """

    try:

        # Run ffprobe to get video stream information in JSON format

        result = subprocess.run([

            'ffprobe', 

            '-v', 'quiet', 

            '-print_format', 'json', 

            '-show_streams', 

            '-select_streams', 'v:0', 

            file_path

        ], capture_output=True, text=True)

        # Parse the JSON output

        probe_data = json.loads(result.stdout)

        # Extract bitrate and resolution

        video_stream = probe_data['streams'][0]

        bitrate = int(video_stream.get('bit_rate', 0)) / 1000  # Convert to kbps

        width = int(video_stream.get('width', 0))

        height = int(video_stream.get('height', 0))

        return bitrate, width, height

    except Exception as e:

        print(f"Error analyzing video: {e}")

        return None, None, None

def categorize_bitrate(bitrate, width, height):

    """

    Categorize bitrate based on resolution and bitrate

    """

    # Categorization based on resolution and typical bitrate recommendations

    if width <= 0 or height <= 0:

        return "Unable to determine resolution"

    # Calculate pixels

    pixels = width * height

    # Bitrate categories for different resolutions

    categories = {

        # 4K (3840x2160)

        (3840 * 2160, float('inf')): {

            'low': (10000, 'Low bitrate for 4K'),

            'medium': (20000, 'Medium bitrate for 4K'),

            'high': (float('inf'), 'High bitrate for 4K')

        },

        # 1080p (1920x1080)

        (1920 * 1080, 3840 * 2160): {

            'low': (5000, 'Low bitrate for 1080p'),

            'medium': (10000, 'Medium bitrate for 1080p'),

            'high': (float('inf'), 'High bitrate for 1080p')

        },

        # 720p (1280x720)

        (1280 * 720, 1920 * 1080): {

            'low': (2500, 'Low bitrate for 720p'),

            'medium': (5000, 'Medium bitrate for 720p'),

            'high': (float('inf'), 'High bitrate for 720p')

        },

        # SD (640x480 or lower)

        (0, 1280 * 720): {

            'low': (1000, 'Low bitrate for SD'),

            'medium': (2500, 'Medium bitrate for SD'),

            'high': (float('inf'), 'High bitrate for SD')

        }

    }

    # Find the right resolution category

    for (min_pixels, max_pixels), thresholds in categories.items():

        if min_pixels < pixels <= max_pixels:

            for category, (threshold, description) in thresholds.items():

                if bitrate <= threshold:

                    return f"{category.capitalize()} Bitrate ({description})"

    return "Unable to categorize"

def main():

    # Prompt for file path

    file_path = input("Enter the full path to the video file: ").strip('"')

    # Validate file exists

    if not os.path.exists(file_path):

        print("File does not exist. Please check the path and try again.")

        return

    # Get bitrate and resolution

    bitrate, width, height = get_video_bitrate_and_resolution(file_path)

    # Check if analysis was successful

    if bitrate is None:

        print("Could not analyze the video file. Ensure ffprobe is installed and the file is a valid video.")

        return

    # Print detailed information

    print(f"\nVideo Analysis:")

    print(f"Resolution: {width}x{height}")

    print(f"Bitrate: {bitrate:.2f} kbps")

    # Categorize bitrate

    category = categorize_bitrate(bitrate, width, height)

    print(f"Bitrate Category: {category}")

if __name__ == "__main__":

    main()