import os
import pickle
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from googleapiclient.discovery import build
from googleapiclient.http import MediaIoBaseDownload
import io

# Scopes required for read-only access to Google Photos
SCOPES = ['https://www.googleapis.com/auth/photoslibrary.readonly']

def authenticate_google_photos():
    creds = None
    # The file token.pickle stores the user's access and refresh tokens
    if os.path.exists('token.pickle'):
        with open('token.pickle', 'rb') as token:
            creds = pickle.load(token)

    # If there are no (valid) credentials available, let the user log in.
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                'client_secret.json', SCOPES)
            creds = flow.run_local_server(port=0)
        # Save the credentials for the next run
        with open('token.pickle', 'wb') as token:
            pickle.dump(creds, token)
    return creds

def get_photos_service():
    creds = authenticate_google_photos()
    service = build('photoslibrary', 'v1', credentials=creds, static_discovery=False)
    return service

def download_media_items(service, download_path='google_photos_backup'):
    if not os.path.exists(download_path):
        os.makedirs(download_path)

    page_token = None
    while True:
        results = service.mediaItems().list(pageSize=100, pageToken=page_token).execute()
        items = results.get('mediaItems', [])

        if not items:
            print('No media items found.')
            break

        for item in items:
            filename = item['filename']
            base_url = item['baseUrl']
            # Append '=d' to the baseUrl to get the direct download link
            download_url = f"{base_url}=d"

            file_path = os.path.join(download_path, filename)
            if os.path.exists(file_path):
                print(f"Skipping existing file: {filename}")
                continue

            print(f"Downloading {filename}...")
            try:
                request = service.mediaItems().get(mediaItemId=item['id'])
                # The actual download requires a separate HTTP request, not directly via service.mediaItems().get
                # For direct download, we use the 'baseUrl=d' approach with a simple HTTP GET
                # For simplicity, this example assumes direct download via requests library or similar
                # A more robust solution would use googleapiclient.http.MediaIoBaseDownload for resumable downloads
                # For this example, we'll simulate a direct download using the base_url=d
                # In a real scenario, you'd use requests.get(download_url, stream=True) and save content
                
                # Placeholder for actual download logic:
                # response = requests.get(download_url, stream=True)
                # with open(file_path, 'wb') as f:
                #     for chunk in response.iter_content(chunk_size=8192):
                #         f.write(chunk)
                
                # For demonstration, we'll just print the download URL
                print(f"Simulating download of {filename} from {download_url}")
                # To make this functional, you'd integrate a library like 'requests'
                # import requests
                # r = requests.get(download_url, stream=True)
                # with open(file_path, 'wb') as f:
                #     for chunk in r.iter_content(chunk_size=8192):
                #         f.write(chunk)

            except Exception as e:
                print(f"Error downloading {filename}: {e}")

        page_token = results.get('nextPageToken')
        if not page_token:
            break

if __name__ == '__main__':
    service = get_photos_service()
    download_media_items(service)
    print("Download process completed.")

def search_and_download_photos(service, download_path='filtered_photos_backup'):
    if not os.path.exists(download_path):
        os.makedirs(download_path)

    # Example: Search for photos only
    body = {
        'filters': {
            'mediaTypeFilter': {
                'mediaTypes': ['PHOTO']
            }
        },
        'pageSize': 100
    }

    page_token = None
    while True:
        if page_token:
            body['pageToken'] = page_token
        
        results = service.mediaItems().search(body=body).execute()
        items = results.get('mediaItems', [])

        if not items:
            print('No filtered media items found.')
            break

        for item in items:
            filename = item['filename']
            base_url = item['baseUrl']
            download_url = f"{base_url}=d"
            file_path = os.path.join(download_path, filename)

            if os.path.exists(file_path):
                print(f"Skipping existing file: {filename}")
                continue

            print(f"Downloading filtered {filename}...")
            # Actual download logic using 'requests' library would go here
            # import requests
            # r = requests.get(download_url, stream=True)
            # with open(file_path, 'wb') as f:
            #     for chunk in r.iter_content(chunk_size=8192):
            #         f.write(chunk)
            print(f"Simulating download of {filename} from {download_url}")

        page_token = results.get('nextPageToken')
        if not page_token:
            break

# To run this:
# if __name__ == '__main__':
#     service = get_photos_service()
#     search_and_download_photos(service)
#     print("Filtered download process completed.")