import vk_api
import requests
import json
import os
import glob
import time
import shutil
import argparse
from tqdm import tqdm
import config
class VKVideoUploader:
 def __init__(self, access_token):
 self.vk_session = vk_api.VkApi(token=access_token)
 self.vk = self.vk_session.get_api()
 def upload_to_group(self, video_path, group_id, title="Group Video", description=""):
 try:
 upload_server = self.vk.video.save(
 group_id=abs(group_id),
 name=title,
 description=description
 )
 
 upload_url = upload_server['upload_url']
 
 file_size = os.path.getsize(video_path)
 
 with open(video_path, 'rb') as video_data:
 print(f" Uploading to group: {title} ({file_size / (1024*1024):.2f} MB)")
 
 class ProgressBar:
 def __init__(self, total_size):
 self.total_size = total_size
 self.progress_bar = tqdm(
 total=total_size,
 unit='B',
 unit_scale=True,
 unit_divisor=1024,
 desc="Uploading",
 bar_format='{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]'
 )
 self.uploaded = 0
 
 def __call__(self, chunk):
 self.uploaded += len(chunk)
 self.progress_bar.update(len(chunk))
 
 def close(self):
 self.progress_bar.close()
 
 class ReadableWithProgress:
 def __init__(self, file_obj, callback):
 self.file_obj = file_obj
 self.callback = callback
 self.total_read = 0
 
 def read(self, size=-1):
 chunk = self.file_obj.read(size)
 if chunk and self.callback:
 self.callback(chunk)
 return chunk
 
 progress_tracker = ProgressBar(file_size)
 
 files = {
 'video_file': (
 os.path.basename(video_path),
 ReadableWithProgress(video_data, progress_tracker),
 'video/mp4'
 )
 }
 
 try:
 response = requests.post(upload_url, files=files)
 finally:
 progress_tracker.close()
 
 if response.status_code == 200:
 result = response.json()
 print(f"✅ Video '{title}' uploaded to group successfully!")
 return result
 else:
 print(f"❌ Upload failed for '{title}': {response.text}")
 return None
 
 except Exception as e:
 print(f"❌ Error uploading '{title}': {str(e)}")
 return None
def upload_all_videos_to_group(input_folder, output_folder, group_id, uploader):
 video_files = glob.glob(os.path.join(input_folder, "*.mp4"))
 
 if not video_files:
 print("⚠️ No .mp4 files found in the input folder.")
 return
 os.makedirs(output_folder, exist_ok=True)
 print(f" Found {len(video_files)} video(s) to upload.")
 
 for i, video_path in enumerate(video_files, 1):
 file_size = os.path.getsize(video_path)
 print(f"{i}. {os.path.basename(video_path)} ({file_size / (1024*1024):.2f} MB)")
 
 print(f"\n{'='*60}")
 print(f" Overall Progress: 0/{len(video_files)} videos")
 print('='*60)
 
 successful_uploads = 0
 failed_uploads = 0
 
 for idx, video_path in enumerate(video_files, 1):
 filename = os.path.basename(video_path)
 title = os.path.splitext(filename)[0]
 
 print(f"\n Processing video {idx}/{len(video_files)}: {filename}")
 print(f"{'='*40}")
 
 result = uploader.upload_to_group(
 video_path=video_path,
 group_id=group_id,
 title=title,
 description=f"Uploaded {time.strftime('%Y-%m-%d %H:%M:%S')}"
 )
 
 if result:
 successful_uploads += 1
 try:
 dest_path = os.path.join(output_folder, filename)
 shutil.move(video_path, dest_path)
 print(f" Moved to: {dest_path}")
 except Exception as move_error:
 print(f"⚠️ Failed to move file: {move_error}")
 else:
 failed_uploads += 1
 
 print(f"{'='*60}")
 print(f" Overall Progress: {idx}/{len(video_files)} videos")
 print(f"✅ Successful: {successful_uploads} | ❌ Failed: {failed_uploads}")
 print(f"{'='*60}")
 
 if idx < len(video_files):
 print("⏳ Waiting 2 seconds before next upload...")
 time.sleep(2)
 
 print(f"\n{'='*60}")
 print(" UPLOAD SUMMARY")
 print(f"{'='*60}")
 print(f" Total videos found: {len(video_files)}")
 print(f"✅ Successfully uploaded: {successful_uploads}")
 print(f"❌ Failed: {failed_uploads}")
 print(f"{'='*60}")
def main():
 parser = argparse.ArgumentParser(description="Upload MP4 videos to a VK group.")
 parser.add_argument(
 "--input",
 type=str,
 default="input",
 help="Input folder containing .mp4 files (default: 'input')"
 )
 parser.add_argument(
 "--output",
 type=str,
 default="output",
 help="Output folder to move uploaded videos (default: 'output')"
 )
 parser.add_argument(
 "--group-id",
 type=int,
 default=config.DEFAULT_GROUP_ID,
 help=f"VK group ID (default: {config.DEFAULT_GROUP_ID})"
 )
 args = parser.parse_args()
 if not os.path.isdir(args.input):
 print(f"❌ Input folder '{args.input}' does not exist.")
 return
 uploader = VKVideoUploader(config.ACCESS_TOKEN)
 upload_all_videos_to_group(args.input, args.output, args.group_id, uploader)
if __name__ == "__main__":
 main()