github.ts

export class PrivateRepoError extends Error {
    constructor() {
        super('Private repository — access token required.');
        this.name = 'PrivateRepoError';
    }
}

export class TokenExpiredError extends Error {
    constructor() {
        super('Access token is invalid or expired.');
        this.name = 'TokenExpiredError';
    }
}

export class RateLimitError extends Error {
    constructor() {
        super(
            'API rate limit exceeded. Authenticated requests get a higher rate limit.'
        );
        this.name = 'RateLimitError';
    }
}

export interface GitHubContext {
    owner: string;
    repo: string;
    branch: string;
    path: string;
}

export interface GitHubFile {
    path: string;
    url: string;
    apiUrl?: string;
}

export const parseGitHubUrl = (url: string): GitHubContext | null => {
    try {
        const u = new URL(url);
        if (u.hostname !== 'github.com') return null;

        const parts = u.pathname.split('/').filter(Boolean);
        if (parts.length < 2) return null;

        const owner = parts[0];
        const repo = parts[1];

        if (parts.length === 2) {
            return { owner, repo, branch: 'HEAD', path: '' };
        }

        if (parts[2] === 'tree' || parts[2] === 'blob') {
            const branch = parts[3];
            const path = parts.slice(4).join('/');
            return { owner, repo, branch, path };
        }

        return null;
    } catch {
        return null;
    }
};

export const getStoredToken = (): Promise<string | null> =>
    new Promise((resolve) => {
        chrome.storage.local.get('github_token', (result) => {
            resolve(result.github_token || null);
        });
    });

export const fetchTree = async (
    context: GitHubContext,
    token?: string | null
): Promise<GitHubFile[]> => {
    const { owner, repo, branch, path } = context;

    const headers: Record<string, string> = {
        Accept: 'application/vnd.github.v3+json',
    };
    if (token) {
        headers['Authorization'] = `Bearer ${token}`;
    }

    const res = await fetch(
        `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`,
        {
            headers,
        }
    );

    if (!res.ok) {
        if (res.status === 404) {
            throw new PrivateRepoError();
        }
        if (res.status === 401) {
            throw new TokenExpiredError();
        }
        if (res.status === 403) {
            throw new RateLimitError();
        }
        throw new Error(
            `Failed to fetch repository tree (HTTP ${res.status}).`
        );
    }

    const data = await res.json();
    if (data.truncated) {
        console.warn(
            'Repository tree is very large and the result was truncated.'
        );
    }

    const files: GitHubFile[] = [];
    const prefix = path ? `${path}/` : '';

    for (const item of data.tree) {
        if (item.type !== 'blob') continue;

        let matched = false;
        let relativePath = item.path;

        if (!path) {
            matched = true;
        } else if (item.path.startsWith(prefix)) {
            matched = true;
            relativePath = item.path.substring(prefix.length);
        } else if (item.path === path) {
            matched = true;
            relativePath = item.path.split('/').pop() || item.path;
        }

        if (matched) {
            files.push({
                path: relativePath,
                url: `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${item.path}`,
                apiUrl: `https://api.github.com/repos/${owner}/${repo}/contents/${item.path}?ref=${branch}`,
            });
        }
    }

    return files;
};

export const fetchFileWithToken = async (
    file: GitHubFile,
    token?: string | null
): Promise<Response> => {
    if (!file.apiUrl) {
        throw new Error(`Missing API URL for file: ${file.path}`);
    }

    const headers: Record<string, string> = {
        Accept: 'application/vnd.github.raw+json',
    };
    if (token) {
        headers['Authorization'] = `Bearer ${token}`;
    }

    const res = await fetch(file.apiUrl, { headers });
    if (res.status === 401) {
        throw new TokenExpiredError();
    }
    if (res.status === 403) {
        throw new RateLimitError();
    }
    return res;
};