def get_authenticated_service():
    flow = flow_from_clientsecrets(
        CLIENT_SECRETS_FILE, scope=SCOPES, message=MISSING_CLIENT_SECRETS_MESSAGE
    )

    oauth_store = BASE_DIR / f"{Path(sys.argv[0]).name}-oauth2.json"
    storage = Storage(str(oauth_store))
    credentials = storage.get()

    if credentials is None or credentials.invalid:
        flags = argparser.parse_args()
        credentials = run_flow(flow, storage, flags)

    return build(
        YOUTUBE_API_SERVICE_NAME,
        YOUTUBE_API_VERSION,
        http=credentials.authorize(httplib2.Http()),
    )

SCOPES = [
    "https://www.googleapis.com/auth/youtube.upload",
    "https://www.googleapis.com/auth/youtube",
    "https://www.googleapis.com/auth/youtubepartner",
]

if automate_youtube_upload:
    client_secrets_file = str((BASE_DIR / "client_secret.json").resolve())
    
    if not os.path.exists(client_secrets_file):
        emit(
            "[-] Client secrets file missing. YouTube upload will be skipped.",
            "warning",
        )
        emit(
            "[-] Please download the client_secret.json from Google Cloud Platform",
            "error",
        )
    else:
        video_metadata = {
            "video_path": final_video_path,
            "title": title,
            "description": description,
            "category": "28",  # Science & Technology
            "keywords": ",".join(keywords),
            "privacyStatus": "private",
        }
        
        try:
            video_response = upload_video(**video_metadata)
            emit(f"Uploaded video ID: {video_response.get('id')}", "success")
        except HttpError as err:
            emit(
                f"An HTTP error {err.resp.status} occurred:\n{err.content}", "error"
            )

def upload_video(video_path, title, description, category, keywords, privacy_status):
    try:
        youtube = get_authenticated_service()
        
        # Get channel ID
        channels_response = youtube.channels().list(mine=True, part="id").execute()
        for channel in channels_response["items"]:
            log(f" => Channel ID: {channel['id']}", "info")
        
        # Upload video
        video_response = initialize_upload(
            youtube,
            {
                "file": video_path,
                "title": title,
                "description": description,
                "category": category,
                "keywords": keywords,
                "privacyStatus": privacy_status,
            },
        )
        return video_response
    except HttpError as e:
        log(f"[-] An HTTP error {e.resp.status} occurred:\n{e.content}", "error")
        raise e

def resumable_upload(insert_request: MediaFileUpload):
    response = None
    error = None
    retry = 0
    
    while response is None:
        try:
            log(" => Uploading file...", "info")
            status, response = insert_request.next_chunk()
            if "id" in response:
                log(f"Video id '{response['id']}' was successfully uploaded.", "success")
                return response
        except HttpError as e:
            if e.resp.status in RETRIABLE_STATUS_CODES:
                error = f"A retriable HTTP error {e.resp.status} occurred:\n{e.content}"
            else:
                raise
        except RETRIABLE_EXCEPTIONS as e:
            error = f"A retriable error occurred: {e}"

        if error is not None:
            log(error, "error")
            retry += 1
            if retry > MAX_RETRIES:
                raise Exception("No longer attempting to retry.")

            max_sleep = 2**retry
            sleep_seconds = random.random() * max_sleep
            log(f" => Sleeping {sleep_seconds} seconds and then retrying...", "info")
            time.sleep(sleep_seconds)

def generate_metadata(
    video_subject: str, script: str, ai_model: str
) -> Tuple[str, str, List[str]]:
    # Generate title
    title_prompt = f"""
    Generate a catchy and SEO-friendly title for a YouTube shorts video about {video_subject}.
    """
    title = generate_response(title_prompt, ai_model).strip()
    
    # Generate description
    description_prompt = f"""
    Write a brief and engaging description for a YouTube shorts video about {video_subject}.
    The video is based on the following script:
    {script}
    """
    description = generate_response(description_prompt, ai_model).strip()
    
    # Generate keywords
    keywords = get_search_terms(video_subject, 6, script, ai_model)
    
    return title, description, keywords

youtube.thumbnails().set(
    videoId=video_response['id'],
    media_body=MediaFileUpload('thumbnail.jpg', mimetype='image/jpeg')
).execute()

youtube.playlistItems().insert(
    part="snippet",
    body={
        "snippet": {
            "playlistId": "PLxxxxxxxxxxxxxx",
            "resourceId": {
                "kind": "youtube#video",
                "videoId": video_response['id']
            }
        }
    }
).execute()