interface PaginationData<T> {
    data: T[];
    count: number;
    per_page?: number;
    page?: string | number;
}

interface PaginationResult<T> {
    data: T[];
    pagination: {
        total_records: number;
        total_perpage: number;
        total_pages: number;
        current_page: number;
        next_page: number | null;
        previous_page: number | null;
    };
}

interface PaginationParams {
    limit: number;
    offset: number;
}

export class PaginationHelper {
    static paginate<T>(data: PaginationData<T>): PaginationResult<T> {
        const total_perpage = Number(data.per_page) || 10;
        const total_pages = Math.ceil(data.count / total_perpage);
        const current_page = Number(data.page) || 1;
        const previous_page = current_page === 1 ? null : current_page - 1;
        const next_page = current_page === total_pages ? null : current_page + 1;

        return {
            data: data.data,
            pagination: {
                total_records: data.count,
                total_perpage,
                total_pages,
                current_page,
                next_page,
                previous_page
            }
        };
    }

    static getPaginationParams(page?: string | number, size?: string | number): PaginationParams {
        const parsedSize = size ? Number(size) : 10;
        const parsedPage = page ? Number(page) - 1 : 0;

        const limit = Math.max(1, parsedSize); // Ensure limit is at least 1
        const offset = Math.max(0, parsedPage) * limit; // Ensure offset is not negative

        return { limit, offset };
    }
}