import os

import sys

from datetime import datetime, timedelta

from PIL import Image

from PIL.ExifTags import TAGS

import shutil

def get_image_datetime(image_path):

    """Extract datetime from image metadata"""

    try:

        img = Image.open(image_path)

        exif = img._getexif()

        if exif:

            for tag, value in exif.items():

                if TAGS.get(tag) == "DateTimeOriginal":

                    return datetime.strptime(value, "%Y:%m:%d %H:%M:%S")

    except (AttributeError, KeyError, ValueError, TypeError):

        pass

    return None

def find_sequences(files_with_dates, min_sequence_length=50):

    """Find sequences of photos taken at regular intervals"""

    if not files_with_dates:

        return []

    # Sort files by datetime

    sorted_files = sorted(files_with_dates, key=lambda x: x[1])

    sequences = []

    current_sequence = [sorted_files[0]]

    for i in range(1, len(sorted_files)):

        prev_file, prev_time = sorted_files[i - 1]

        curr_file, curr_time = sorted_files[i]

        time_diff = curr_time - prev_time

        if not current_sequence:

            current_sequence.append((curr_file, curr_time))

            continue

        # Check if this photo continues the sequence

        if len(current_sequence) == 1:

            # First interval - can't determine pattern yet

            current_sequence.append((curr_file, curr_time))

            continue

        # Calculate expected time based on established interval

        first, second = current_sequence[0][1], current_sequence[1][1]

        interval = second - first

        expected_time = current_sequence[-1][1] + interval

        tolerance = timedelta(seconds=interval.total_seconds() * 0.1)  # 10% tolerance

        if abs(curr_time - expected_time) <= tolerance:

            current_sequence.append((curr_file, curr_time))

        else:

            # Sequence broken

            if len(current_sequence) >= min_sequence_length:

                sequences.append(current_sequence)

            current_sequence = [(curr_file, curr_time)]

    # Add the last sequence if it's long enough

    if len(current_sequence) >= min_sequence_length:

        sequences.append(current_sequence)

    return sequences

def scan_directory(root_dir):

    """Scan directory recursively for image files"""

    image_extensions = {".jpg", ".jpeg", ".png", ".tiff", ".nef", ".cr2", ".arw"}

    files_with_dates = []

    for dirpath, _, filenames in os.walk(root_dir):

        for filename in filenames:

            ext = os.path.splitext(filename.lower())[1]

            if ext in image_extensions:

                filepath = os.path.join(dirpath, filename)

                try:

                    dt = get_image_datetime(filepath)

                    if dt:

                        files_with_dates.append((filepath, dt))

                except Image.DecompressionBombError:

                    print(f"Skipping large image file: {filepath}")

                    continue

    return files_with_dates

def format_sequence_info(sequence):

    """Format sequence information for display"""

    first_file = sequence[0][0]

    last_file = sequence[-1][0]

    count = len(sequence)

    interval = sequence[1][1] - sequence[0][1]

    dirname = os.path.dirname(first_file)

    first_filename = os.path.basename(first_file)

    last_filename = os.path.basename(last_file)

    return {

        "count": count,

        "directory": dirname,

        "first": first_filename,

        "last": last_filename,

        "interval": interval,

    }

def move_sequence(sequence, base_dir):

    """Move sequence to its own folder"""

    if not sequence:

        return

    first_file = sequence[0][0]

    dirname = os.path.dirname(first_file)

    seq_start = sequence[0][1].strftime("%Y%m%d_%H%M%S")

    seq_end = sequence[-1][1].strftime("%H%M%S")

    new_dirname = os.path.join(base_dir, f"timelapse_{seq_start}-{seq_end}")

    os.makedirs(new_dirname, exist_ok=True)

    for filepath, _ in sequence:

        filename = os.path.basename(filepath)

        new_path = os.path.join(new_dirname, filename)

        shutil.move(filepath, new_path)

    return new_dirname

def main():

    if len(sys.argv) < 2:

        print("Usage: python timelapse_detector.py <directory>")

        return

    root_dir = sys.argv[1]

    print(f"Scanning {root_dir} for timelapse sequences...")

    files_with_dates = scan_directory(root_dir)

    sequences = find_sequences(files_with_dates)

    if not sequences:

        print("No timelapse sequences found.")

        return

    print(f"\nFound {len(sequences)} timelapse sequences:")

    sequence_info = []

    for i, seq in enumerate(sequences, 1):

        info = format_sequence_info(seq)

        sequence_info.append(info)

        print(f"\nSequence {i}:")

        print(f"  Photos: {info['count']}")

        print(f"  Directory: {info['directory']}")

        print(f"  First file: {info['first']}")

        print(f"  Last file: {info['last']}")

        print(

            f"  Interval: ~{info['interval'].total_seconds():.1f} seconds between photos"

        )

    response = (

        input("\nWould you like to move these sequences to their own folders? (y/n): ")

        .strip()

        .lower()

    )

    if response == "y":

        base_dir = os.path.abspath(root_dir)

        for i, seq in enumerate(sequences, 1):

            new_dir = move_sequence(seq, base_dir)

            print(f"Moved sequence {i} to {new_dir}")

        print("\nDone moving sequences.")

    else:

        print("No files were moved.")

if __name__ == "__main__":

    main()