"""
Militant API SDK for Python
Official Python client for the Militant API

Installation:
    pip install requests

Usage:
    from militant import MilitantClient
    
    client = MilitantClient('https://militant.revlibertaire.com')
    client.login('username', 'password')
    
    # Get timeline
    posts = client.get_timeline()
    
    # Create post
    client.create_post('Hello from Python!')
"""

import requests
from typing import Optional, Dict, List, Any
from datetime import datetime

class MilitantClient:
    def __init__(self, base_url: str):
        """Initialize Militant API client
        
        Args:
            base_url: Base URL of the Militant instance (e.g., 'https://militant.revlibertaire.com')
        """
        self.base_url = base_url.rstrip('/')
        self.api_url = f"{self.base_url}/api/v1"
        self.token: Optional[str] = None
        self.session = requests.Session()
    
    def _request(self, method: str, endpoint: str, **kwargs) -> Dict[str, Any]:
        """Make API request"""
        url = f"{self.api_url}/{endpoint}"
        headers = kwargs.pop('headers', {})
        
        if self.token:
            headers['Authorization'] = f'Bearer {self.token}'
        
        response = self.session.request(method, url, headers=headers, **kwargs)
        response.raise_for_status()
        return response.json()
    
    # Authentication
    def login(self, username: str, password: str) -> Dict[str, Any]:
        """Login and get API token"""
        data = self._request('POST', 'auth.php?action=login', json={
            'username': username,
            'password': password
        })
        self.token = data['data']['token']
        return data['data']
    
    def refresh_token(self) -> Dict[str, Any]:
        """Refresh current token"""
        data = self._request('POST', 'auth.php?action=refresh', json={
            'token': self.token
        })
        self.token = data['data']['token']
        return data['data']
    
    def revoke_token(self):
        """Revoke current token"""
        self._request('POST', 'auth.php?action=revoke', json={
            'token': self.token
        })
        self.token = None
    
    # Posts
    def get_timeline(self, page: int = 1, per_page: int = 20) -> Dict[str, Any]:
        """Get timeline posts"""
        return self._request('GET', f'posts.php?page={page}&per_page={per_page}')
    
    def get_post(self, post_id: int) -> Dict[str, Any]:
        """Get single post"""
        return self._request('GET', f'posts.php?id={post_id}')
    
    def get_user_posts(self, user_id: int, page: int = 1, per_page: int = 20) -> Dict[str, Any]:
        """Get user's posts"""
        return self._request('GET', f'posts.php?user_id={user_id}&page={page}&per_page={per_page}')
    
    def create_post(self, content: str, media: Optional[str] = None) -> Dict[str, Any]:
        """Create new post"""
        return self._request('POST', 'posts.php', json={
            'content': content,
            'media': media
        })
    
    def update_post(self, post_id: int, content: str) -> Dict[str, Any]:
        """Update post"""
        return self._request('PUT', f'posts.php?id={post_id}', json={
            'content': content
        })
    
    def delete_post(self, post_id: int) -> Dict[str, Any]:
        """Delete post"""
        return self._request('DELETE', f'posts.php?id={post_id}')
    
    # Group Posts
    def get_group_posts(self, group_id: int, page: int = 1) -> Dict[str, Any]:
        """Get group posts"""
        return self._request('GET', f'group_posts.php?group_id={group_id}&page={page}')
    
    def create_group_post(self, group_id: int, content: str, media: Optional[str] = None) -> Dict[str, Any]:
        """Create new group post"""
        return self._request('POST', 'group_posts.php', json={
            'group_id': group_id,
            'content': content,
            'media': media
        })

    def update_group_post(self, post_id: int, content: str) -> Dict[str, Any]:
        """Update group post"""
        return self._request('PUT', 'group_posts.php', json={
             'id': post_id,
             'content': content
        })

    def delete_group_post(self, post_id: int) -> Dict[str, Any]:
        """Delete group post"""
        return self._request('DELETE', f'group_posts.php?id={post_id}')

    # Group Comments
    def get_group_comments(self, post_id: int, page: int = 1) -> Dict[str, Any]:
        """Get group post comments"""
        return self._request('GET', f'group_comments.php?post_id={post_id}&page={page}')

    def create_group_comment(self, post_id: int, content: str) -> Dict[str, Any]:
        """Create group post comment"""
        return self._request('POST', 'group_comments.php', json={
            'post_id': post_id,
            'content': content
        })

    def update_group_comment(self, comment_id: int, content: str) -> Dict[str, Any]:
        """Update group post comment"""
        return self._request('PUT', 'group_comments.php', json={
            'id': comment_id,
            'content': content
        })

    def delete_group_comment(self, comment_id: int) -> Dict[str, Any]:
        """Delete group post comment"""
        return self._request('DELETE', f'group_comments.php?id={comment_id}')
    
    # Users
    def get_user(self, user_id: Optional[int] = None) -> Dict[str, Any]:
        """Get user profile"""
        endpoint = 'users.php' if not user_id else f'users.php?id={user_id}'
        return self._request('GET', endpoint)
    
    def update_profile(self, **kwargs) -> Dict[str, Any]:
        """Update own profile"""
        return self._request('PUT', 'users.php', json=kwargs)
    
    # Comments
    def get_comments(self, post_id: int, page: int = 1, per_page: int = 20) -> Dict[str, Any]:
        """Get post comments"""
        return self._request('GET', f'comments.php?post_id={post_id}&page={page}&per_page={per_page}')
    
    def create_comment(self, post_id: int, content: str) -> Dict[str, Any]:
        """Create comment"""
        return self._request('POST', 'comments.php', json={
            'post_id': post_id,
            'content': content
        })
    
    def delete_comment(self, comment_id: int) -> Dict[str, Any]:
        """Delete comment"""
        return self._request('DELETE', f'comments.php?id={comment_id}')
    
    # Likes
    def like_post(self, post_id: int) -> Dict[str, Any]:
        """Like a post"""
        return self._request('POST', 'likes.php', json={'post_id': post_id})
    
    def unlike_post(self, post_id: int) -> Dict[str, Any]:
        """Unlike a post"""
        return self._request('DELETE', f'likes.php?post_id={post_id}')
    
    # Follows
    def follow_user(self, user_id: int) -> Dict[str, Any]:
        """Follow a user"""
        return self._request('POST', 'follows.php', json={'user_id': user_id})
    
    def unfollow_user(self, user_id: int) -> Dict[str, Any]:
        """Unfollow a user"""
        return self._request('DELETE', f'follows.php?user_id={user_id}')
    
    def get_followers(self, user_id: Optional[int] = None, page: int = 1) -> Dict[str, Any]:
        """Get followers"""
        uid = user_id or ''
        return self._request('GET', f'follows.php?user_id={uid}&type=followers&page={page}')
    
    def get_following(self, user_id: Optional[int] = None, page: int = 1) -> Dict[str, Any]:
        """Get following"""
        uid = user_id or ''
        return self._request('GET', f'follows.php?user_id={uid}&type=following&page={page}')
    
    # Messages
    def get_conversations(self, page: int = 1) -> Dict[str, Any]:
        """Get conversations list"""
        return self._request('GET', f'messages.php?page={page}')
    
    def get_messages(self, conversation_id: int, page: int = 1) -> Dict[str, Any]:
        """Get messages in conversation"""
        return self._request('GET', f'messages.php?conversation_id={conversation_id}&page={page}')
    
    def send_message(self, content: str, conversation_id: Optional[int] = None, 
                    recipient_id: Optional[int] = None, media: Optional[str] = None) -> Dict[str, Any]:
        """Send message"""
        return self._request('POST', 'messages.php', json={
            'content': content,
            'conversation_id': conversation_id,
            'recipient_id': recipient_id,
            'media': media
        })
    
    # Notifications
    def get_notifications(self, page: int = 1, unread_only: bool = False) -> Dict[str, Any]:
        """Get notifications"""
        unread = 'true' if unread_only else 'false'
        return self._request('GET', f'notifications.php?page={page}&unread={unread}')
    
    def mark_notification_read(self, notification_id: int) -> Dict[str, Any]:
        """Mark notification as read"""
        return self._request('PUT', f'notifications.php?id={notification_id}')
    
    def mark_all_notifications_read(self) -> Dict[str, Any]:
        """Mark all notifications as read"""
        return self._request('PUT', 'notifications.php', json={'mark_all': True})
    
    # Search
    def search(self, query: str, search_type: str = 'all', page: int = 1) -> Dict[str, Any]:
        """Search users, posts, etc."""
        return self._request('GET', f'search.php?q={query}&type={search_type}&page={page}')
    
    # Bookmarks
    def get_bookmarks(self, page: int = 1) -> Dict[str, Any]:
        """Get bookmarked posts"""
        return self._request('GET', f'bookmarks.php?page={page}')
    
    def bookmark_post(self, post_id: int) -> Dict[str, Any]:
        """Bookmark a post"""
        return self._request('POST', 'bookmarks.php', json={'post_id': post_id})
    
    def unbookmark_post(self, post_id: int) -> Dict[str, Any]:
        """Remove bookmark"""
        return self._request('DELETE', f'bookmarks.php?post_id={post_id}')

    # Groups
    def get_user_groups(self) -> Dict[str, Any]:
        """Get user's groups"""
        return self._request('GET', 'groups.php')

    def get_group(self, group_id: int) -> Dict[str, Any]:
        """Get group details"""
        return self._request('GET', f'groups.php?id={group_id}')

    def create_group(self, name: str, description: str, privacy: str = 'public') -> Dict[str, Any]:
        """Create a new group"""
        return self._request('POST', 'groups.php', json={
            'action': 'create',
            'name': name,
            'description': description,
            'privacy': privacy
        })

    def join_group(self, group_id: int) -> Dict[str, Any]:
        """Join a group"""
        return self._request('POST', f'groups.php?path={group_id}/join')

    def leave_group(self, group_id: int) -> Dict[str, Any]:
        """Leave a group"""
        return self._request('DELETE', f'groups.php?path={group_id}/leave')

    # Stories
    def get_stories(self) -> Dict[str, Any]:
        """Get active stories"""
        return self._request('GET', 'stories.php')

    def create_story(self, media: str, text: Optional[str] = None) -> Dict[str, Any]:
        """Create a story"""
        return self._request('POST', 'stories.php', json={
            'media': media,
            'text': text
        })

    def delete_story(self, story_id: int) -> Dict[str, Any]:
        """Delete a story"""
        return self._request('DELETE', f'stories.php?id={story_id}')

    # Pages
    def get_pages(self) -> Dict[str, Any]:
        """Get pages list"""
        return self._request('GET', 'pages.php')

    def get_page(self, page_id: int) -> Dict[str, Any]:
        """Get page details"""
        return self._request('GET', f'pages.php?id={page_id}')

    def create_page(self, name: str, category: str, description: str) -> Dict[str, Any]:
        """Create a page"""
        return self._request('POST', 'pages.php', json={
            'name': name,
            'category': category,
            'description': description
        })

    def like_page(self, page_id: int) -> Dict[str, Any]:
        """Like a page"""
        return self._request('POST', f'pages.php?path={page_id}/like')

    # Events
    def get_events(self) -> Dict[str, Any]:
        """Get events list"""
        return self._request('GET', 'events.php')

    def get_event(self, event_id: int) -> Dict[str, Any]:
        """Get event details"""
        return self._request('GET', f'events.php?id={event_id}')

    def create_event(self, title: str, description: str, date: str, location: str, image: Optional[str] = None) -> Dict[str, Any]:
        """Create an event"""
        return self._request('POST', 'events.php', json={
            'title': title,
            'description': description,
            'event_date': date,
            'location': location,
            'image': image
        })

    def join_event(self, event_id: int) -> Dict[str, Any]:
        """Join an event"""
        return self._request('POST', f'events.php?path={event_id}/join')

    def delete_event(self, event_id: int) -> Dict[str, Any]:
        """Delete an event"""
        return self._request('DELETE', f'events.php?id={event_id}')

    # Albums
    def get_albums(self) -> Dict[str, Any]:
        """Get albums list"""
        return self._request('GET', 'albums.php')

    def get_album(self, album_id: int) -> Dict[str, Any]:
        """Get album details"""
        return self._request('GET', f'albums.php?id={album_id}')

    def create_album(self, title: str, description: Optional[str] = None) -> Dict[str, Any]:
        """Create an album"""
        return self._request('POST', 'albums.php', json={
            'title': title,
            'description': description
        })

    def add_photo_to_album(self, album_id: int, media: str, description: Optional[str] = None) -> Dict[str, Any]:
        """Add photo to album"""
        return self._request('POST', f'albums.php?path={album_id}/photos', json={
            'media': media,
            'description': description
        })

    def delete_album(self, album_id: int) -> Dict[str, Any]:
        """Delete an album"""
        return self._request('DELETE', f'albums.php?id={album_id}')

    # Lives
    def get_lives(self) -> Dict[str, Any]:
        """Get active lives"""
        return self._request('GET', 'lives.php')

    def get_live(self, live_id: int) -> Dict[str, Any]:
        """Get live details"""
        return self._request('GET', f'lives.php?path={live_id}')

    def start_live(self, title: str) -> Dict[str, Any]:
        """Start a live stream"""
        return self._request('POST', 'lives.php', json={'title': title})

    def end_live(self, live_id: int) -> Dict[str, Any]:
        """End a live stream"""
        return self._request('PUT', f'lives.php?path={live_id}/end')

    def join_live(self, live_id: int) -> Dict[str, Any]:
        """Join a live as viewer"""
        params = {'action': 'join'} # API endpoint structure might vary, assume POST join
        return self._request('POST', f'lives.php?path={live_id}/join')

    def send_live_comment(self, live_id: int, content: str) -> Dict[str, Any]:
        """Send comment on live"""
        return self._request('POST', f'lives.php?path={live_id}/comments', json={'content': content})

    # Moderation & Reports
    def get_reports(self, page: int = 1) -> Dict[str, Any]:
        """Get reports"""
        return self._request('GET', f'reports.php?page={page}')

    def create_report(self, reason: str, post_id: Optional[int] = None, user_id: Optional[int] = None, description: Optional[str] = None) -> Dict[str, Any]:
        """Create a report"""
        data = {'reason': reason}
        if post_id: data['post_id'] = post_id
        if user_id: data['user_id'] = user_id
        if description: data['description'] = description
        return self._request('POST', 'reports.php', json=data)

    def vote_on_report(self, report_id: int, vote: str) -> Dict[str, Any]:
        """Vote on a report (remove, warn, keep)"""
        return self._request('POST', 'reports.php', json={'report_id': report_id, 'vote': vote})

    def get_moderators(self) -> Dict[str, Any]:
        """Get moderators list"""
        return self._request('GET', 'moderators.php')

    def apply_for_moderator(self, motivation: str) -> Dict[str, Any]:
        """Apply for moderator position"""
        return self._request('POST', 'moderators.php', json={'motivation': motivation, 'action': 'apply'})

    def get_my_sanctions(self) -> Dict[str, Any]:
        """Get my sanctions"""
        return self._request('GET', 'sanctions.php')

    # Media Upload
    def upload_media(self, file_path: str) -> Dict[str, Any]:
        """Upload a file (image/video)"""
        url = f"{self.api_url}/upload.php"
        headers = {'Authorization': f'Bearer {self.token}'} if self.token else {}
        
        with open(file_path, 'rb') as f:
            files = {'file': f}
            # Note: Do not set Content-Type header manually when using files in requests,
            # requests lib sets it with boundary automatically.
            response = self.session.post(url, headers=headers, files=files)
        
        response.raise_for_status()
        return response.json()

    # Data Export
    def export_data(self) -> Dict[str, Any]:
        """Export all user data"""
        return self._request('GET', 'export.php')

    # Discover
    def discover(self, discover_type: str = 'all') -> Dict[str, Any]:
        """Discover new users, groups, and pages
        
        Args:
            discover_type: 'all', 'users', 'groups', or 'pages'
        """
        return self._request('GET', f'discover.php?type={discover_type}')

    # Account Deletion
    def delete_account(self, password: str) -> Dict[str, Any]:
        """Request account deletion (sends confirmation email)
        
        Args:
            password: Current password for verification
        """
        return self._request('POST', 'delete_account.php', json={'password': password})

    # Reactions
    def add_reaction(self, post_id: int, reaction_type: str = 'like') -> Dict[str, Any]:
        """Add reaction to a post"""
        return self._request('POST', 'reactions.php', json={
            'post_id': post_id,
            'reaction_type': reaction_type
        })

    def remove_reaction(self, post_id: int) -> Dict[str, Any]:
        """Remove reaction from a post"""
        return self._request('DELETE', f'reactions.php?post_id={post_id}')

    def get_reactions(self, post_id: int) -> Dict[str, Any]:
        """Get reactions for a post"""
        return self._request('GET', f'reactions.php?post_id={post_id}')

    # Group Reactions
    def add_group_reaction(self, post_id: int, reaction_type: str = 'like') -> Dict[str, Any]:
        """Add reaction to a group post"""
        return self._request('POST', 'group_reactions.php', json={
            'post_id': post_id,
            'reaction_type': reaction_type
        })

    def remove_group_reaction(self, post_id: int) -> Dict[str, Any]:
        """Remove reaction from a group post"""
        return self._request('DELETE', f'group_reactions.php?post_id={post_id}')


# Example usage
if __name__ == '__main__':
    # Initialize client
    client = MilitantClient('https://militant.revlibertaire.com')
    
    # Login
    client.login('your_username', 'your_password')
    
    # Get timeline
    timeline = client.get_timeline()
    print(f"Got {len(timeline['data']['items'])} posts")
    
    # Create post
    post = client.create_post('Hello from Python SDK!')
    print(f"Created post: {post['data']['id']}")
    
    # Like the post
    client.like_post(post['data']['id'])
    print("Post liked!")

    
    # Calls (Flutter app only - requires X-Flutter-App header)
    # Note: These methods are for reference only. WebRTC calls require native mobile implementation.
    
    def initiate_call(self, recipient_id: Optional[int] = None, group_id: Optional[int] = None, 
                     call_type: str = 'audio', offer_sdp: str = '') -> Dict[str, Any]:
        """Initiate an audio/video call
        
        Args:
            recipient_id: User ID for 1-to-1 call
            group_id: Group ID for group call
            call_type: 'audio' or 'video'
            offer_sdp: WebRTC SDP offer string
            
        Returns:
            Call details with call_id
            
        Note:
            Requires X-Flutter-App: militant-flutter-v1 header
            This is a Flutter-only feature
        """
        data = {
            'call_type': call_type,
            'offer': offer_sdp
        }
        
        if recipient_id:
            data['recipient_id'] = recipient_id
        elif group_id:
            data['group_id'] = group_id
        else:
            raise ValueError("Either recipient_id or group_id must be provided")
        
        headers = {'X-Flutter-App': 'militant-flutter-v1'}
        return self._request('POST', 'calls.php?action=initiate', json=data, headers=headers)
    
    def answer_call(self, call_id: str, answer_sdp: str) -> Dict[str, Any]:
        """Answer an incoming call
        
        Args:
            call_id: Call ID
            answer_sdp: WebRTC SDP answer string
            
        Returns:
            Call status
        """
        data = {
            'call_id': call_id,
            'answer': answer_sdp
        }
        headers = {'X-Flutter-App': 'militant-flutter-v1'}
        return self._request('POST', 'calls.php?action=answer', json=data, headers=headers)
    
    def join_group_call(self, call_id: str, offer_sdp: str) -> Dict[str, Any]:
        """Join a group call
        
        Args:
            call_id: Call ID
            offer_sdp: WebRTC SDP offer string
            
        Returns:
            Call details with other participants
        """
        data = {
            'call_id': call_id,
            'offer': offer_sdp
        }
        headers = {'X-Flutter-App': 'militant-flutter-v1'}
        return self._request('POST', 'calls.php?action=join', json=data, headers=headers)
    
    def send_ice_candidate(self, call_id: str, candidate: Dict[str, Any]) -> Dict[str, Any]:
        """Send ICE candidate for WebRTC connection
        
        Args:
            call_id: Call ID
            candidate: ICE candidate dict with 'candidate', 'sdpMid', 'sdpMLineIndex'
            
        Returns:
            Success message
        """
        data = {
            'call_id': call_id,
            'candidate': candidate
        }
        headers = {'X-Flutter-App': 'militant-flutter-v1'}
        return self._request('POST', 'calls.php?action=ice_candidate', json=data, headers=headers)
    
    def restart_ice(self, call_id: str, offer_sdp: str) -> Dict[str, Any]:
        """Restart ICE negotiation (for network changes)
        
        Args:
            call_id: Call ID
            offer_sdp: New WebRTC SDP offer string
            
        Returns:
            Success message
        """
        data = {
            'call_id': call_id,
            'offer': offer_sdp
        }
        headers = {'X-Flutter-App': 'militant-flutter-v1'}
        return self._request('POST', 'calls.php?action=ice_restart', json=data, headers=headers)
    
    def reject_call(self, call_id: str) -> Dict[str, Any]:
        """Reject an incoming call
        
        Args:
            call_id: Call ID
            
        Returns:
            Success message
        """
        data = {'call_id': call_id}
        headers = {'X-Flutter-App': 'militant-flutter-v1'}
        return self._request('POST', 'calls.php?action=reject', json=data, headers=headers)
    
    def end_call(self, call_id: str) -> Dict[str, Any]:
        """End an active call
        
        Args:
            call_id: Call ID
            
        Returns:
            Success message
        """
        data = {'call_id': call_id}
        headers = {'X-Flutter-App': 'militant-flutter-v1'}
        return self._request('POST', 'calls.php?action=end', json=data, headers=headers)
    
    def poll_call_updates(self, call_id: str, last_poll: Optional[str] = None) -> Dict[str, Any]:
        """Poll for call updates (status, ICE candidates, etc.)
        
        Args:
            call_id: Call ID
            last_poll: Last poll timestamp (optional)
            
        Returns:
            Call updates including status, ICE candidates, participants
        """
        params = {'call_id': call_id}
        if last_poll:
            params['last_poll'] = last_poll
        
        headers = {'X-Flutter-App': 'militant-flutter-v1'}
        return self._request('GET', 'calls.php?action=poll', params=params, headers=headers)
    
    def get_call_history(self, page: int = 1, per_page: int = 50) -> Dict[str, Any]:
        """Get call history
        
        Args:
            page: Page number
            per_page: Results per page
            
        Returns:
            Paginated call history
        """
        params = {
            'page': page,
            'per_page': per_page
        }
        headers = {'X-Flutter-App': 'militant-flutter-v1'}
        return self._request('GET', 'calls.php?action=history', params=params, headers=headers)

    # ==================== Additional Endpoints ====================

    def change_password(self, current_password: str, new_password: str) -> Dict[str, Any]:
        """Change user password"""
        return self._request('POST', 'change_password.php', json={
            'current_password': current_password,
            'new_password': new_password
        })

    def add_comment_reaction(self, comment_id: int, reaction_type: str = 'like', comment_type: str = 'post') -> Dict[str, Any]:
        """Add or update reaction on a comment"""
        return self._request('POST', 'comment_reactions.php', json={
            'comment_id': comment_id,
            'reaction_type': reaction_type,
            'comment_type': comment_type
        })

    def remove_comment_reaction(self, comment_id: int, comment_type: str = 'post') -> Dict[str, Any]:
        """Remove reaction from a comment"""
        return self._request('DELETE', f'comment_reactions.php?comment_id={comment_id}&comment_type={comment_type}')

    def get_comment_reactions(self, comment_id: int, comment_type: str = 'post') -> Dict[str, Any]:
        """Get all reactions for a comment"""
        return self._request('GET', f'comment_reactions.php?comment_id={comment_id}&comment_type={comment_type}')

    def get_friends(self, friend_type: str = 'all', page: int = 1, per_page: int = 20) -> Dict[str, Any]:
        """Get friends list or pending requests"""
        params = {'type': friend_type, 'page': page, 'per_page': per_page}
        return self._request('GET', 'friends.php', params=params)

    def send_friend_request(self, user_id: int) -> Dict[str, Any]:
        """Send a friend request"""
        return self._request('POST', 'friends.php', json={'action': 'send', 'user_id': user_id})

    def accept_friend_request(self, request_id: int) -> Dict[str, Any]:
        """Accept a friend request"""
        return self._request('POST', 'friends.php', json={'action': 'accept', 'request_id': request_id})

    def reject_friend_request(self, request_id: int) -> Dict[str, Any]:
        """Reject a friend request"""
        return self._request('POST', 'friends.php', json={'action': 'reject', 'request_id': request_id})

    def remove_friend(self, user_id: int) -> Dict[str, Any]:
        """Remove a friend"""
        return self._request('DELETE', f'friends.php?user_id={user_id}')

    def get_message_groups(self) -> Dict[str, Any]:
        """Get all message groups for user"""
        return self._request('GET', 'message_groups.php')

    def get_message_group(self, group_id: int) -> Dict[str, Any]:
        """Get message group details"""
        return self._request('GET', f'message_groups.php?path={group_id}')

    def get_group_messages(self, group_id: int, page: int = 1, limit: int = 50) -> Dict[str, Any]:
        """Get messages in a group"""
        params = {'page': page, 'limit': limit}
        return self._request('GET', f'message_groups.php?path={group_id}/messages', params=params)

    def create_message_group(self, name: str, member_ids: Optional[List[int]] = None, avatar: str = 'default.svg') -> Dict[str, Any]:
        """Create a new message group"""
        return self._request('POST', 'message_groups.php', json={
            'name': name,
            'avatar': avatar,
            'member_ids': member_ids or []
        })

    def send_group_message(self, group_id: int, content: str, media: Optional[str] = None, media_type: str = 'image') -> Dict[str, Any]:
        """Send message to a group"""
        return self._request('POST', f'message_groups.php?path={group_id}/messages', json={
            'content': content,
            'media': media,
            'media_type': media_type
        })

    def add_group_member(self, group_id: int, user_id: int) -> Dict[str, Any]:
        """Add member to a group"""
        return self._request('POST', f'message_groups.php?path={group_id}/members', json={'user_id': user_id})

    def remove_group_member(self, group_id: int, user_id: int) -> Dict[str, Any]:
        """Remove member from a group"""
        return self._request('DELETE', f'message_groups.php?path={group_id}/members/{user_id}')

    def update_message_group(self, group_id: int, name: Optional[str] = None, auto_delete_time: Optional[int] = None, make_everyone_admin: bool = False) -> Dict[str, Any]:
        """Update message group settings"""
        data = {}
        if name:
            data['name'] = name
        if auto_delete_time is not None:
            data['auto_delete_time'] = auto_delete_time
        if make_everyone_admin:
            data['make_everyone_admin'] = True
        return self._request('PUT', f'message_groups.php?path={group_id}', json=data)

    def leave_message_group(self, group_id: int) -> Dict[str, Any]:
        """Leave a message group"""
        return self._request('DELETE', f'message_groups.php?path={group_id}')

    def delete_group_message(self, message_id: int) -> Dict[str, Any]:
        """Delete a message from a group"""
        return self._request('DELETE', f'message_groups.php?path=messages/{message_id}')

    def edit_group_message(self, message_id: int, content: str) -> Dict[str, Any]:
        """Edit a message in a group"""
        return self._request('PUT', f'message_groups.php?path=messages/{message_id}', json={'content': content})

    def get_public_settings(self) -> Dict[str, Any]:
        """Get public settings (OneSignal App ID, etc.)"""
        return self._request('GET', 'settings.php')

    def get_two_factor_status(self) -> Dict[str, Any]:
        """Get 2FA status and setup info"""
        return self._request('GET', 'two_factor.php')

    def enable_two_factor(self, code: str) -> Dict[str, Any]:
        """Enable 2FA with verification code"""
        return self._request('POST', 'two_factor.php?action=enable', json={'code': code})

    def disable_two_factor(self) -> Dict[str, Any]:
        """Disable 2FA"""
        return self._request('DELETE', 'two_factor.php')

    def get_user_preferences(self) -> Dict[str, Any]:
        """Get user preferences (language, notifications, privacy)"""
        return self._request('GET', 'user_preferences.php')

    def update_user_preferences(self, **preferences) -> Dict[str, Any]:
        """Update user preferences"""
        return self._request('PUT', 'user_preferences.php', json=preferences)

    def share_post(self, post_id: int, content: Optional[str] = None) -> Dict[str, Any]:
        """Share a post"""
        data = {'post_id': post_id}
        if content:
            data['content'] = content
        return self._request('POST', 'shares.php', json=data)

    def get_post_shares(self, post_id: int, page: int = 1) -> Dict[str, Any]:
        """Get shares of a post"""
        return self._request('GET', f'shares.php?post_id={post_id}&page={page}')