import { createAsyncThunk } from '@reduxjs/toolkit';
import { get, post, put, del, upload } from '../../services/api';
import { showNotification } from '../notification.slice';

/**
 * Fetch knowledge bases with pagination
 * @param {Object} params - Pagination parameters
 * @param {number} params.page - Page number (default: 1)
 * @param {number} params.page_size - Page size (default: 10)
 */
export const fetchKnowledgeBases = createAsyncThunk(
    'knowledgeBase/fetchKnowledgeBases',
    async ({ page = 1, page_size = 10 } = {}, { rejectWithValue }) => {
        try {
            const response = await get('/knowledge-bases', { params: { page, page_size } });
            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                return response.data.data;
            }
            return response.data;
        } catch (error) {
            console.log(error);

            return rejectWithValue(error.response?.data.error.message || 'Failed to fetch knowledge bases');
        }
    }
);

/**
 * Search knowledge bases
 * @param {Object} params - Search parameters
 * @param {string} params.keyword - Search keyword
 * @param {number} params.page - Page number (default: 1)
 * @param {number} params.page_size - Page size (default: 10)
 */
export const searchKnowledgeBases = createAsyncThunk('knowledgeBase/search', async (params, { rejectWithValue }) => {
    try {
        const { keyword, page = 1, page_size = 10 } = params;
        const response = await get('/knowledge-bases/search', {
            params: {
                keyword,
                page,
                page_size,
            },
        });

        // 处理新的返回格式
        if (response.data && response.data.code === 200) {
            return response.data;
        }
        return response.data;
    } catch (error) {
        return rejectWithValue(error.response?.data?.message || error.message);
    }
});

/**
 * Create a new knowledge base
 */
export const createKnowledgeBase = createAsyncThunk(
    'knowledgeBase/createKnowledgeBase',
    async (knowledgeBaseData, { rejectWithValue }) => {
        try {
            const response = await post('/knowledge-bases/', knowledgeBaseData);

            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                return response.data.data.knowledge_base;
            }

            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data?.message || 'Failed to create knowledge base');
        }
    }
);

/**
 * Get knowledge base details by ID
 */
export const getKnowledgeBaseById = createAsyncThunk(
    'knowledgeBase/getKnowledgeBaseById',
    async (id, { rejectWithValue }) => {
        try {
            const response = await get(`/knowledge-bases/${id}/`);
            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                return response.data.data;
            }
            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data?.message || 'Failed to get knowledge base details');
        }
    }
);

/**
 * Update knowledge base
 * @param {Object} params - Update parameters
 * @param {string} params.id - Knowledge base ID
 * @param {Object} params.data - Update data (name, desc)
 */
export const updateKnowledgeBase = createAsyncThunk(
    'knowledgeBase/updateKnowledgeBase',
    async ({ id, data }, { rejectWithValue }) => {
        try {
            const response = await put(`/knowledge-bases/${id}/`, data);

            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                return response.data.data.knowledge_base;
            }

            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data?.message || 'Failed to update knowledge base');
        }
    }
);

/**
 * Delete knowledge base
 * @param {string} id - Knowledge base ID
 */
export const deleteKnowledgeBase = createAsyncThunk(
    'knowledgeBase/deleteKnowledgeBase',
    async (id, { rejectWithValue }) => {
        try {
            await del(`/knowledge-bases/${id}/`);
            return id;
        } catch (error) {
            return rejectWithValue(error.response?.data?.message || 'Failed to delete knowledge base');
        }
    }
);

/**
 * Change knowledge base type
 * @param {Object} params - Parameters
 * @param {string} params.id - Knowledge base ID
 * @param {string} params.type - New knowledge base type
 * @param {string} params.department - User department
 * @param {string} params.group - User group
 */
export const changeKnowledgeBaseType = createAsyncThunk(
    'knowledgeBase/changeType',
    async ({ id, type, department, group }, { rejectWithValue }) => {
        try {
            const response = await post(`/knowledge-bases/${id}/change_type/`, {
                type,
                department,
                group,
            });

            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                return response.data.data;
            }

            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data?.message || '修改知识库类型失败');
        }
    }
);

/**
 * 申请知识库访问权限
 * @param {Object} params - 参数
 * @param {string} params.knowledge_base - 知识库ID
 * @param {Object} params.permissions - 权限对象
 * @param {string} params.reason - 申请原因
 * @param {string} params.expires_at - 过期时间
 * @returns {Promise} - Promise对象
 */
export const requestKnowledgeBaseAccess = createAsyncThunk(
    'knowledgeBase/requestAccess',
    async (params, { rejectWithValue, dispatch }) => {
        try {
            const response = await post('/permissions/', params);
            dispatch(
                showNotification({
                    type: 'success',
                    message: '权限申请已发送，请等待管理员审核',
                })
            );
            return response.data;
        } catch (error) {
            dispatch(
                showNotification({
                    type: 'danger',
                    message: error.response?.data?.detail || '权限申请失败，请稍后重试',
                })
            );
            return rejectWithValue(error.response?.data?.message || error.message);
        }
    }
);

/**
 * Upload a document to a knowledge base
 * @param {Object} params - Upload parameters
 * @param {string} params.knowledge_base_id - Knowledge base ID
 * @param {File} params.file - File to upload
 */
export const uploadDocument = createAsyncThunk(
    'knowledgeBase/uploadDocument',
    async ({ knowledge_base_id, file }, { rejectWithValue, dispatch }) => {
        try {
            const formData = new FormData();
            formData.append('file', file);

            const response = await post(`/knowledge-bases/${knowledge_base_id}/upload_document/`, formData, true);

            dispatch(
                showNotification({
                    type: 'success',
                    message: `文档 ${file.name} 上传成功`,
                })
            );

            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                return response.data.data;
            }

            return response.data;
        } catch (error) {
            const errorMessage = error.response?.data?.message || error.message || '文档上传失败';
            dispatch(
                showNotification({
                    type: 'danger',
                    message: errorMessage,
                })
            );
            return rejectWithValue(errorMessage);
        }
    }
);