// SeaQA Question Interfaces
interface SeaQAQuestionInterface {
    id?: number;
    accountId: number | null;
    userId: number;
    title: string;
    code: string;
    description?: string;
    status: 'pending' | 'approved' | 'rejected' | 'merged' | 'closed';
    mergedIntoQuestionId: number | null;
    isGoodQuestion: boolean;
    approvedByAdminId: number | null;
    approvedAt: Date | null;
    rejectedReason: string | null;
    views: number;
    answersCount: number;
    likesCount: number;
    bookmarksCount: number;
    createdAt?: Date;
    updatedAt?: Date;
    deletedAt?: Date | null;
    questionContent?: SeaQAQuestionContentInterface;
    questionContents?: SeaQAQuestionContentInterface[];
}

interface SeaQAQuestionContentInterface {
    id?: number;
    questionId: number;
    languageId: number;
    title: string;
    description?: string;
    descriptionText?: string;
    createdAt?: Date;
    updatedAt?: Date;
    deletedAt?: Date | null;
}

interface SeaQAQuestionRequest {
    title: string;
    description?: string;
    categoryIds: number[];
}

interface SeaQAQuestionUpdateRequest {
    title?: string;
    description?: string;
    status?: 'pending' | 'approved' | 'rejected' | 'merged' | 'closed';
    categoryIds?: number[];
}


interface SeaQAQuestionAdminActionRequest {
    ids: number[];
    status: 'approved' | 'rejected' | 'merged' | 'closed';
    rejectedReason?: string;
    mergedIntoQuestionId?: number;
}

interface SeaQAAnswerAdminActionRequest {
    ids: number[];
    status: 'published' | 'rejected';
    rejectedReason?: string;
}


interface SeaQAQuestionResponse extends SeaQAQuestionInterface {
    author: UserPublicObjectInterface;
    categories: CategoryObjectSummaryInteface[];
    isLiked: boolean;
    isBookmarked: boolean;
    answers?: SeaQAAnswerResponse[];
    myAnswer?: SeaQAAnswerResponse | null;
}

// SeaQA Answer Interfaces
interface SeaQAAnswerInterface {
    id?: number;
    questionId: number;
    userId: number;
    body: string;
    status: 'draft' | 'pending_approval' | 'published' | 'rejected';
    rejectedReason: string | null;
    isFeatured: boolean;
    featuredAt: Date | null;
    editedAt: Date | null;
    requiresApproval: boolean;
    wordCount: number;
    likesCount: number;
    bookmarksCount: number;
    createdAt?: Date;
    updatedAt?: Date;
    deletedAt?: Date | null;
    answerContent?: SeaQAAnswerContentInterface;
    answerContents?: SeaQAAnswerContentInterface[];
}

interface SeaQAAnswerContentInterface {
    id?: number;
    answerId: number;
    languageId: number;
    body: string;
    createdAt?: Date;
    updatedAt?: Date;
    deletedAt?: Date | null;
}

interface SeaQAAnswerRequest {
    body: string;
    status: 'draft' | 'pending_approval' | 'published';
}

interface SeaQAAnswerUpdateRequest {
    body?: string;
    status?: 'draft' | 'pending_approval' | 'published';
}

interface SeaQAAnswerResponse extends SeaQAAnswerInterface {
    author: UserPublicObjectInterface;
    commentsCount: number;
    isLiked: boolean;
    isBookmarked: boolean;
    comments?: SeaQACommentResponse[];
    question?: any;
}

// SeaQA Comment Interfaces
interface SeaQACommentInterface {
    id?: number;
    answerId: number;
    userId: number;
    content: string;
    parentId: number | null;
    createdAt?: Date;
    updatedAt?: Date;
    deletedAt?: Date | null;
}

interface SeaQACommentRequest {
    content: string;
    parentId?: number | null;
}

interface SeaQACommentListRequest {
    userId?: number;
}

interface SeaQACommentGlobalListRequest {
    page: number;
    perPage: number;
    sortBy: string;
    sortDirection: 'asc' | 'desc';
    userId?: number;
    answerId?: number;
}

interface SeaQACommentPaginatedData {
    data: SeaQACommentResponse[];
    page: number;
    perPage: number;
    totalRecords: number;
    totalPages: number;
}

interface SeaQACommentResponse {
    id?: number;
    content: string;
    createdAt?: Date;
    author: UserPublicObjectInterface;
    replies?: SeaQACommentResponse[];
}

// SeaQA Like Interfaces
interface SeaQALikeInterface {
    id?: number;
    userId: number;
    entityId: number;
    entityType: 'question' | 'answer';
    createdAt?: Date;
    updatedAt?: Date;
}

// SeaQA Bookmark Interfaces
interface SeaQABookmarkInterface {
    id?: number;
    userId: number;
    entityId: number;
    entityType: 'question' | 'answer';
    createdAt?: Date;
    updatedAt?: Date;
}

// Applicability Interfaces
interface CategoryApplicabilityInterface {
    id?: number;
    categoryId: number;
    applicableRanks: number[] | null;
    applicableShipTypes: number[] | null;
    applicableTo: string | null; // Seafarer, Ashore, Others
    createdAt?: Date;
    updatedAt?: Date;
}

interface CategoryApplicabilityRequest {
    applicableRankId: number;
    applicableShipTypeId: number;
    applicableTo: string; // Seafarer, Ashore, Others
}


// User Followed Topic Interfaces
interface UserFollowedTopicInterface {
    id?: number;
    userId: number;
    categoryId: number;
    createdAt?: Date;
    updatedAt?: Date;
}

// Paginated Data
interface SeaQAQuestionPaginatedData {
    data: SeaQAQuestionResponse[];
    page: number;
    perPage: number;
    totalRecords: number;
    totalPages: number;
}

interface SeaQAQuestionListRequest {
    page: number;
    perPage: number;
    searchText?: string;
    sortBy?: string;
    sortDirection?: 'asc' | 'desc';
    status?: string;
    categoryIds?: number[];
    isTrending?: boolean;
    isGoodQuestion?: boolean;
    isGoodRandom?: boolean;
    goodQuestionsRandom?: boolean;
    goodQuestionsOnTopRandom?: boolean;
    myQuestions?: boolean;
    answerFilter?: 'short_answers' | 'long_answers' | 'reviewed_answers' | 'not_reviewed_answers' | 'featured_answers' | 'answered' | 'unanswered';
    userId?: number;
    bookmarkedByUserId?: number;
}

interface SeaQAAnswerListRequest {
    page: number;
    perPage: number;
    questionId?: number;
    status?: string;
    isFeatured?: boolean;
    myAnswers?: boolean;
    drafts?: boolean;
    sortBy?: string;
    sortDirection?: 'asc' | 'desc';
    includeQuestion?: boolean;
    userId?: number;
    bookmarkedByUserId?: number;
}

interface SeaQAAnswerPaginatedData {
    data: SeaQAAnswerResponse[];
    page: number;
    perPage: number;
    totalRecords: number;
    totalPages: number;
}

interface SeaQAQuestionSimpleResponse {
    id: number;
    title: string;
    code: string;
    status: string;
}

interface SeaQAQuestionSimplePaginatedData {
    data: SeaQAQuestionSimpleResponse[];
    page: number;
    perPage: number;
    totalRecords: number;
    totalPages: number;
}