import asyncio
from pyrogram import Client
from tgcaller import TgCaller

# Initialize
app = Client("my_session", api_id=API_ID, api_hash=API_HASH)
caller = TgCaller(app)

@caller.on_stream_end
async def on_stream_end(client, update):
    print(f"Stream ended in {update.chat_id}")

async def main():
    await caller.start()
    
    # Join voice call
    await caller.join_call(-1001234567890)
    
    # Play audio
    await caller.play(-1001234567890, "song.mp3")
    
    # Play video
    await caller.play(-1001234567890, "video.mp4")

if __name__ == "__main__":
    asyncio.run(main())

from tgcaller import AudioConfig

# High-quality audio
audio_config = AudioConfig(
    bitrate=128000,           # 128 kbps
    sample_rate=48000,        # 48 kHz
    channels=2,               # Stereo
    noise_suppression=True,   # Clean audio
    echo_cancellation=True    # No echo
)

await caller.play(chat_id, "audio.mp3", audio_config=audio_config)

from tgcaller import VideoConfig

# HD video streaming
video_config = VideoConfig(
    width=1920,
    height=1080,
    fps=30,
    bitrate=2000000,          # 2 Mbps
    codec="h264"
)

await caller.play(chat_id, "video.mp4", video_config=video_config)

from tgcaller.advanced import BridgedCallManager

bridge_manager = BridgedCallManager(caller)
await bridge_manager.create_bridge("conference", [chat1, chat2, chat3])

from tgcaller.advanced import MicrophoneStreamer

mic_streamer = MicrophoneStreamer(caller, chat_id)
await mic_streamer.start_streaming()

from tgcaller.advanced import ScreenShareStreamer

screen_streamer = ScreenShareStreamer(caller, chat_id)
await screen_streamer.start_streaming(monitor_index=1)

from tgcaller.advanced import YouTubeStreamer

youtube = YouTubeStreamer(caller)
await youtube.play_youtube_url(chat_id, "https://youtube.com/watch?v=...")

from tgcaller.advanced import WhisperTranscription

transcriber = WhisperTranscription("base")
await transcriber.start_transcription()

from tgcaller.advanced import AudioFilters, VideoFilters

audio_filters = AudioFilters()
video_filters = VideoFilters()

# Add echo effect
filtered_audio = audio_filters.apply_echo(audio_data, delay=0.3)

# Add blur effect
filtered_video = video_filters.apply_blur(video_frame, kernel_size=15)

from tgcaller.advanced import CustomAPIHandler

api = CustomAPIHandler(caller, port=8080)
await api.start_server()

# Now you can control via HTTP:
# POST /play {"chat_id": -1001234567890, "source": "song.mp3"}

from tgcaller import TgCaller
from pyrogram import Client, filters

app = Client("music_bot")
caller = TgCaller(app)

@app.on_message(filters.command("play"))
async def play_music(client, message):
    if len(message.command) < 2:
        return await message.reply("Usage: /play <song_name>")
    
    song = message.command[1]
    
    # Join call if not already joined
    if not caller.is_connected(message.chat.id):
        await caller.join_call(message.chat.id)
    
    # Play song
    await caller.play(message.chat.id, f"music/{song}.mp3")
    await message.reply(f" Playing: {song}")

@caller.on_stream_end
async def next_song(client, update):
    # Auto-play next song logic here
    pass

app.run()

from tgcaller.advanced import BridgedCallManager, WhisperTranscription

# Create conference bridge
bridge_manager = BridgedCallManager(caller)
await bridge_manager.create_bridge("meeting", [chat1, chat2, chat3])

# Add real-time transcription
transcriber = WhisperTranscription("base")
await transcriber.start_transcription()

from tgcaller import TgCaller

caller = TgCaller(app, ffmpeg_parameters={
    'before_options': '-re',
    'options': '-vn -preset ultrafast'
})

# Manage multiple Telegram accounts
clients = [Client(f"session_{i}") for i in range(5)]
callers = [TgCaller(client) for client in clients]

# Start all
for caller in callers:
    await caller.start()

from tgcaller.advanced import P2PCallManager

p2p = P2PCallManager(caller)
await p2p.create_direct_call(user1_id, user2_id)