# github_permissions.py
from github import Github

class PermissionManager:
    def __init__(self, token):
        self.github = Github(token)
    
    def grant_permission(self, repo_name, username, permission='read'):
        """
        権限を付与する
        permission: 'read', 'write', 'admin'
        """
        repo = self.github.get_repo(repo_name)
        
        # 既存の権限を確認
        try:
            current = repo.get_collaborator_permission(username)
            print(f"Current permission: {current}")
        except:
            print("User is not a collaborator")
        
        # 権限を設定
        repo.add_to_collaborators(username, permission=permission)
        print(f"Granted {permission} to {username}")
    
    def audit_permissions(self, repo_name):
        """リポジトリの権限を監査"""
        repo = self.github.get_repo(repo_name)
        
        permissions = {
            'admin': [],
            'write': [],
            'read': []
        }
        
        for collab in repo.get_collaborators():
            perm = repo.get_collaborator_permission(collab.login)
            permissions[perm].append(collab.login)
        
        return permissions

# branch_protection_config.py
BRANCH_RULES = {
    'main': {
        'protection_level': 'strict',
        'required_reviews': 2,
        'dismiss_stale_reviews': True,
        'require_code_owner_reviews': True,
        'required_status_checks': [
            'test-suite',
            'security-scan',
            'build'
        ],
        'enforce_admins': True
    },
    
    'staging': {
        'protection_level': 'moderate',
        'required_reviews': 1,
        'dismiss_stale_reviews': True,
        'require_code_owner_reviews': False,
        'required_status_checks': [
            'test-suite',
            'build'
        ],
        'enforce_admins': False
    },
    
    'develop': {
        'protection_level': 'light',
        'required_reviews': 1,
        'dismiss_stale_reviews': False,
        'require_code_owner_reviews': False,
        'required_status_checks': [
            'test-suite'
        ],
        'enforce_admins': False
    },
    
    'feature/*': {
        'protection_level': 'none',
        'required_reviews': 0
    }
}

# custom_status_check.py
import requests
from datetime import datetime

class DeploymentGatekeeper:
    def check_deployment_window(self):
        now = datetime.now()
        
        # 営業時間外のチェック
        if now.hour < 9 or now.hour > 18:
            return {
                'state': 'failure',
                'description': 'Deployments only allowed during business hours',
                'context': 'deployment/time-window'
            }
            
        # 金曜午後のチェック
        if now.weekday() == 4 and now.hour >= 15:
            return {
                'state': 'failure',
                'description': 'No Friday afternoon deployments',
                'context': 'deployment/time-window'
            }
            
        return {
            'state': 'success',
            'description': 'Deployment window is open',
            'context': 'deployment/time-window'
        }

# update_codeowners.py
import yaml
from pathlib import Path

class CodeOwnersManager:
    def __init__(self, teams_config_path):
        with open(teams_config_path) as f:
            self.teams = yaml.safe_load(f)
    
    def generate_codeowners(self):
        lines = ["# Auto-generated CODEOWNERS file\n"]
        lines.append("# Last updated: " + datetime.now().isoformat() + "\n\n")
        
        # グローバルルール
        lines.append("# Global owners\n")
        lines.append(f"* @{self.teams['global']['tech_lead']}\n\n")
        
        # チーム別ルール
        for team_name, team_config in self.teams['teams'].items():
            lines.append(f"# {team_name.title()} Team\n")
            
            for path in team_config['paths']:
                owners = ' '.join([f"@{owner}" for owner in team_config['owners']])
                lines.append(f"{path} {owners}\n")
            
            lines.append("\n")
        
        # セキュリティルール
        lines.append("# Security-sensitive files\n")
        for pattern in self.teams['security']['patterns']:
            lines.append(f"{pattern} @{self.teams['security']['team']}\n")
        
        return ''.join(lines)
    
    def update_codeowners_file(self):
        content = self.generate_codeowners()
        
        with open('.github/CODEOWNERS', 'w') as f:
            f.write(content)
        
        # 変更をコミット
        import subprocess
        subprocess.run(['git', 'add', '.github/CODEOWNERS'])
        subprocess.run(['git', 'commit', '-m', 'chore: Update CODEOWNERS'])

# review_bot.py
from github import Github
import re

class ReviewBot:
    def __init__(self, token):
        self.github = Github(token)
        self.review_patterns = {
            'security': {
                'patterns': [
                    r'password\s*=',
                    r'api_key\s*=',
                    r'secret\s*='
                ],
                'reviewers': ['@security-team']
            },
            'performance': {
                'patterns': [
                    r'for .+ in .+:\s*for',  # Nested loops
                    r'\.objects\.all\(\)',    # Django ORM N+1
                ],
                'reviewers': ['@performance-team']
            }
        }
    
    def analyze_pr(self, repo_name, pr_number):
        repo = self.github.get_repo(repo_name)
        pr = repo.get_pull(pr_number)
        
        required_reviewers = set()
        comments = []
        
        # 変更されたファイルを分析
        for file in pr.get_files():
            content = self.get_file_content(file)
            
            for category, config in self.review_patterns.items():
                for pattern in config['patterns']:
                    if re.search(pattern, content):
                        required_reviewers.update(config['reviewers'])
                        comments.append(
                            f"Pattern detected in {file.filename}: "
                            f"{category} review required"
                        )
        
        return {
            'reviewers': list(required_reviewers),
            'comments': comments
        }

class PermissionResolver:
    def __init__(self):
        self.permission_levels = {
            'none': 0,
            'read': 1,
            'triage': 2,
            'write': 3,
            'maintain': 4,
            'admin': 5
        }
    
    def resolve_permission(self, user, repo):
        """ユーザーの最終的な権限を解決"""
        permissions = []
        
        # 1. 直接付与された権限
        direct_permission = self.get_direct_permission(user, repo)
        if direct_permission:
            permissions.append(direct_permission)
        
        # 2. チーム経由の権限
        for team in user.teams:
            team_permission = self.get_team_permission(team, repo)
            if team_permission:
                permissions.append(team_permission)
        
        # 3. 組織のベース権限
        org_permission = self.get_org_base_permission(user, repo.org)
        if org_permission:
            permissions.append(org_permission)
        
        # 最も高い権限を返す
        if not permissions:
            return 'none'
            
        return max(permissions, 
                  key=lambda p: self.permission_levels[p])
    
    def get_effective_permissions(self, user, repo):
        """実効権限の詳細を取得"""
        permission = self.resolve_permission(user, repo)
        
        return {
            'level': permission,
            'source': self.get_permission_source(user, repo),
            'capabilities': self.get_capabilities(permission),
            'restrictions': self.get_restrictions(user, repo)
        }

# permission_audit.py
class PermissionAuditor:
    def __init__(self, org_name):
        self.org_name = org_name
        self.audit_log = []
    
    def audit_all_repos(self):
        """全リポジトリの権限を監査"""
        org = self.github.get_organization(self.org_name)
        
        for repo in org.get_repos():
            self.audit_repo(repo)
    
    def audit_repo(self, repo):
        """個別リポジトリの監査"""
        issues = []
        
        # 管理者が多すぎないか
        admins = self.get_admins(repo)
        if len(admins) > 3:
            issues.append({
                'type': 'excessive_admins',
                'repo': repo.name,
                'count': len(admins),
                'users': admins
            })
        
        # 非アクティブユーザーの確認
        for collab in repo.get_collaborators():
            last_active = self.get_last_activity(collab, repo)
            if last_active > 90:  # 90日以上非アクティブ
                issues.append({
                    'type': 'inactive_user',
                    'repo': repo.name,
                    'user': collab.login,
                    'days_inactive': last_active
                })
        
        # 外部コラボレーターの確認
        external = self.get_external_collaborators(repo)
        for user in external:
            issues.append({
                'type': 'external_collaborator',
                'repo': repo.name,
                'user': user,
                'permission': self.get_permission(user, repo)
            })
        
        return issues
    
    def generate_report(self):
        """監査レポートの生成"""
        report = {
            'timestamp': datetime.now().isoformat(),
            'organization': self.org_name,
            'summary': {
                'total_repos': len(self.audit_log),
                'issues_found': sum(len(r['issues']) for r in self.audit_log),
                'critical_issues': self.count_critical_issues()
            },
            'details': self.audit_log
        }
        
        return report