/**
 * 消息数据服务 - 真实 supadb 集成版本
 * 严格遵循 UTS Android 要求，使用真实的 AkSupa 组件
 */

import supa from '@/components/supadb/aksupainstance.uts'
import type { AkReqResponse } from '@/uni_modules/ak-req/index.uts'
import type {
	Message,
	MessageType,
	MessageRecipient,
	MessageGroup,
	MessageStats,
	MessageListParams,
	SendMessageParams,
	UserOption,
	MessageSenderType,
	MessageReceiverType,
	MessageContentType,
	MessageStatus,
	RecipientStatus,
	DeliveryMethod,
	GroupType,
	MemberRole,
	MemberStatus
} from './msgTypes.uts'

// 定义 GroupMember 类型，如果在 msgTypes.uts 中没有的话
type GroupMember = {
	id : string;
	group_id : string;
	user_id : string;
	role : MemberRole;
	status : MemberStatus;
	joined_at : string;
	updated_at : string;
}

/**
 * 消息数据服务- 真实 supadb 版本
 * 提供消息系统的所有数据操作
 * 统一使用 aksupainstance.uts 
 */
export class MsgDataServiceReal {

	/**
	 * 获取消息类型列表
	 */
	static async getMessageTypes() : Promise<AkReqResponse<Array<MessageType>>> {
		try {
			const response = await supa
				.from('ak_message_types')
				.select('*', {})
				.eq('is_active', true)
				.order('priority', { ascending: false })
				.executeAs<MessageType>()

			if (response.status >= 200 && response.status < 300 && response.data !== null) {
				console.log(response)
				return response
			}

			// 如果没有数据，返回默认的消息类型
			return createErrorResponse<Array<MessageType>>([{
				id: 'default',
				code: 'default',
				name: '普通消息',
				description: '默认消息类型',
				icon: null,
				color: '#757575',
				priority: 50,
				is_system: false,
				is_active: true,
				auto_read_timeout: null,
				retention_days: 30,
				created_at: new Date().toISOString(),
				updated_at: new Date().toISOString()
			}], '无消息类型数据', 200)
		} catch (error) {
			// 出错时也返回默认的消息类型
			return createErrorResponse<Array<MessageType>>([{
				id: 'default',
				code: 'default',
				name: '普通消息',
				description: '默认消息类型',
				icon: null,
				color: '#757575',
				priority: 50,
				is_system: false,
				is_active: true,
				auto_read_timeout: null,
				retention_days: 30,
				created_at: new Date().toISOString(),
				updated_at: new Date().toISOString()
			}], typeof error === 'string' ? error : error?.message ?? '获取消息类型失败', 200)
		}
	}
	/**
   * 获取消息列表
   */
	static async getMessages(params : MessageListParams) : Promise<AkReqResponse<Array<Message>>> {
		try {
			let query = supa
				.from('ak_messages')
				.select(`
                    *,
                    message_type:ak_message_types(*),
                    recipients:ak_message_recipients(*)
                `, {})
				.eq('is_deleted', false)			// 添加筛选条件
			if (params.message_type != null) {
				query = query.eq('message_type', params.message_type as string)
			}
			if (params.sender_type != null) {
				query = query.eq('sender_type', params.sender_type as string)
			}
			if (params.sender_id != null) {
				query = query.eq('sender_id', params.sender_id as string)
			}
			if (params.receiver_type != null) {
				query = query.eq('receiver_type', params.receiver_type as string)
			}
			if (params.receiver_id != null) {
				query = query.eq('receiver_id', params.receiver_id as string)
			}
			if (params.status != null) {
				query = query.eq('status', params.status as string)
			}
			if (params.is_urgent != null) {
				query = query.eq('is_urgent', params.is_urgent as boolean)
			}
			const keyword = params.search
			if (keyword != null && keyword !== '') {
				query = query.or(`title.ilike.%${keyword}%,content.ilike.%${keyword}%`)
			}
			const limit = params.limit ?? 20
			const offset = params.offset ?? 0
			// 分页和排序
			const page = Math.floor(offset / limit) + 1
			const response = await query
				.order('created_at', { ascending: false })
				.range(offset, offset + limit - 1)
				.executeAs<Message>()
				// .execute()
			console.log(response)
			return response
		} catch (error) {
			console.log(error)
			return createErrorResponse<Array<UTSJSONObject>>([],
				typeof error === 'string' ? error : error?.message ?? '获取消息列表失败')
		}
	}

	/**
	 * 获取单条消息详情
	 */
	static async getMessageById(id : string) : Promise<AkReqResponse<Message>> {
		try {
			const response = await supa
				.from('ak_messages')
				.select(`
                    *,
                    message_type:ak_message_types(*),
                    recipients:ak_message_recipients(*)
                `, {})
				.eq('id', id)
				.single()
				.executeAs<Message>()

			return response
		} catch (error) {
			return {
				status: 500,
				data: null,
				error: new UniError(typeof error === 'string' ? error : error?.message ?? '获取消息内容失败'),
				origin: null,
				headers: {}
			} as AkReqResponse<Message>
		}
	}

	/**
	 * 发送消�?
	 */
	static async sendMessage(params : SendMessageParams) : Promise<AkReqResponse<Message>> {
		try {


			// 构建消息数据
			const messageData = {
				message_type_id: params.message_type_id,
				sender_type: params.sender_type,
				sender_id: params.sender_id,
				sender_name: params.sender_name,
				receiver_type: params.receiver_type,
				receiver_id: params.receiver_id,
				title: params.title,
				content: params.content,
				content_type: params.content_type !== null ? params.content_type : 'text',
				attachments: params.attachments,
				media_urls: params.media_urls,
				metadata: params.metadata,
				is_urgent: params.is_urgent !== null ? params.is_urgent : false,
				scheduled_at: params.scheduled_at,
				expires_at: params.expires_at,
				status: 'pending',
				is_deleted: false,
				created_at: new Date().toISOString(),
				updated_at: new Date().toISOString()
			}

			// 插入消息
			const response = await supa
				.from('ak_messages')
				.insert(messageData)
				.single()
				.executeAs<Message>()

			if (response.status >= 200 && response.status < 300) {
				const message = response.data as Message

				// 创建接收记录
				// 批量接收人安全判断
				const receiversArr = params.receivers ?? []
				if (Array.isArray(receiversArr) && receiversArr.length > 0) {
					const recipients = receiversArr.map(receiverId => ({
						message_id: message.id,
						receiver_type: params.receiver_type,
						receiver_id: receiverId,
						status: 'unread',
						is_deleted: false,
						created_at: new Date().toISOString(),
						updated_at: new Date().toISOString()
					}))
					for (const rec of recipients) {
						await supa
							.from('ak_message_recipients')
							.insert(rec)
							.executeAs<MessageRecipient>()
					}
				}

				return response
			} else {
				return response
			}
		} catch (error) {
			return {
				status: 500,
				data: null,
				error: new UniError(typeof error === 'string' ? error : error?.message ?? '发送消息失败'),
				headers: {},
				total: null,
				page: null,
				limit: null,
				hasmore: false,
				origin: null
			}
		}
	}

	/**
	 * 标记消息为已读
	 */
	static async markAsRead(messageId : string, receiverId : string) : Promise<AkReqResponse<boolean>> {
		try {
			// 验证参数不能为空
			if (messageId == null || messageId === '' || receiverId == null || receiverId === '' || receiverId.trim() === '') {
				return createErrorResponse<boolean>(
					false,
					'参数错误：消息ID和接收者ID不能为空'
				)
			}

			const response = await supa
				.from('ak_message_recipients')
				.update({
					status: 'read',
					read_at: new Date().toISOString(),
					updated_at: new Date().toISOString()
				})
				.eq('message_id', messageId)
				.eq('recipient_id', receiverId)
				.executeAs<Array<MessageRecipient>>()

			return {
				status: response.status,
				data: Array.isArray(response.data) ,
				headers: response.headers,
				error: response.error,
				total: response.total,
				page: response.page,
				limit: response.limit,
				hasmore: response.hasmore,
				origin: response.origin
			}
		} catch (error) {
			return createErrorResponse<boolean>(
				false,
				typeof error === 'string' ? error : error?.message ?? '标记已读失败'
			)
		}
	}

	/**
	 * 删除消息
	 */
	static async deleteMessage(messageId : string, userId : string) : Promise<AkReqResponse<boolean>> {
		try {
			// 软删除消息（对发送者）
			await supa
				.from('ak_messages')
				.update({
					is_deleted: true,
					updated_at: new Date().toISOString()
				})
				.eq('id', messageId)
				.eq('sender_id', userId)
				.executeAs<Array<Message>>()

			// 软删除接收记录（对接收者）
			await supa
				.from('ak_message_recipients')
				.update({
					is_deleted: true,
					updated_at: new Date().toISOString()
				})
				.eq('message_id', messageId)
				.eq('recipient_id', userId)
				.executeAs<Array<MessageRecipient>>()
			const aaa = {
				status: 200,
				data: true,
				error: null,
				origin: null,
				headers: {}
			} 
			return  aaa
		} catch (error) {
			const aaa = {
				status: 500,
				data: false,
				error: new UniError(typeof error === 'string' ? error : error?.message ?? '删除消息失败'),
				origin: null,
				headers: {}
			} 
			return aaa
		}
	}

	/**
	 * 批量操作消息
	 */
	static async batchOperation(
		messageIds : Array<string>,
		operation : string,
		userId : string
	) : Promise<AkReqResponse<boolean>> {
		try {
			// 验证参数不能为空
			if (userId == null || userId === '' || userId.trim() === '') {
				return createErrorResponse<boolean>(
					false,
					'参数错误：用户ID不能为空'
				)
			}

			if (messageIds == null || messageIds.length === 0) {
				return createErrorResponse<boolean>(
					false,
					'参数错误：消息ID列表不能为空'
				)
			}

			switch (operation) {
				case 'read':
					await supa
						.from('ak_message_recipients')
						.update({
							status: 'read',
							read_at: new Date().toISOString(),
							updated_at: new Date().toISOString()
						})
						.in('message_id', messageIds.map(x => x as any))
						.eq('recipient_id', userId)
						.executeAs<Array<MessageRecipient>>()
					break

				case 'delete':
					await supa
						.from('ak_message_recipients')
						.update({
							is_deleted: true,
							updated_at: new Date().toISOString()
						})
						.in('message_id', messageIds.map(x => x as any))
						.eq('recipient_id', userId)
						.executeAs<Array<MessageRecipient>>()
					break

				default:
					return {
						status: 400,
						data: false,
						error: new UniError('不支持的批量操作'),
						origin: null,
						headers: {}
					} as AkReqResponse<boolean>
			}

			return {
				status: 200,
				data: true,
				error: null,
				origin: null,
				headers: {}
			} as AkReqResponse<boolean>
		} catch (error) {
			return {
				status: 500,
				data: false,
				error: new UniError(typeof error === 'string' ? error : error?.message ?? '批量操作失败'),
				origin: null,
				headers: {}
			} as AkReqResponse<boolean>
		}
	}

	/**
	 * 获取消息统计信息
	 */
	static async getMessageStats(userId : string) : Promise<AkReqResponse<MessageStats>> {
		try {
			// 验证参数不能为空
			if (userId == null || userId === '' || userId.trim() === '') {
				return createErrorResponse<MessageStats>(
					{
						total_messages: 0,
						unread_messages: 0,
						sent_messages: 0,
						received_messages: 0,
						urgent_messages: 0,
						draft_messages: 0
					},
					'参数错误：用户ID不能为空'
				)
			}

			// 获取未读消息
			const unreadResponse = await supa
				.from('ak_message_recipients')
				.select('id', { count: 'exact' })
				.eq('recipient_id', userId)
				.eq('status', 'unread')
				.eq('is_deleted', false)
				.executeAs<Array<MessageRecipient>>()

			// 获取总消息数
			const totalResponse = await supa
				.from('ak_message_recipients')
				.select('id', { count: 'exact' })
				.eq('recipient_id', userId)
				.eq('is_deleted', false)
				.executeAs<Array<MessageRecipient>>()

			// 获取紧急消息数
			const urgentResponse = await supa
				.from('ak_messages')
				.select('id', { count: 'exact' })
				.eq('receiver_id', userId)
				.eq('is_urgent', true)
				.eq('is_deleted', false)
				.executeAs<Array<Message>>()
		const stats : MessageStats = {
			total_messages: Array.isArray(totalResponse.data) ? (totalResponse.data as Array<any>).length : 0,
			unread_messages: Array.isArray(unreadResponse.data) ? (unreadResponse.data as Array<any>).length : 0,
			urgent_messages: Array.isArray(urgentResponse.data) ? (urgentResponse.data as Array<any>).length : 0,
			sent_messages: 0, // 可根据业务补充
			received_messages: 0, // 可根据业务补充
			draft_messages: 0 // 可根据业务补充
		}

			return {
				status: 200,
				data: stats,
				error: null,
				origin: null,
				headers: {}
			} as AkReqResponse<MessageStats>
		} catch (error) {
			return {
				status: 500,
				data: null,
				error: new UniError(typeof error === 'string' ? error : error?.message ?? '获取消息统计失败'),
				origin: null,
				headers: {}
			} as AkReqResponse<MessageStats>
		}
	}

	/**
	 * 搜索用户（用于消息接收者选择）
	 */
	static async searchUsers(keyword : string) : Promise<AkReqResponse<Array<UserOption>>> {
		try {
			const response = await supa
				.from('ak_users')
				.select('id, username, nickname, avatar', { count: 'exact' })
				.or(`username.ilike.%${keyword}%,nickname.ilike.%${keyword}%`)
				.limit(20)
				.executeAs<Array<UserOption>>()

			return response
		} catch (error) {		return {
			status: 500,
			data: [] as Array<UserOption>,
			error: new UniError(typeof error === 'string' ? error : error?.message ?? '搜索失败'),
			origin: null,
			headers: {}
		} as AkReqResponse<Array<UserOption>>
		}
	}

	/**
	 * 获取群组列表
	 */
	static async getGroups() : Promise<AkReqResponse<Array<MessageGroup>>> {
		try {
			const response = await supa
				.from('ak_message_groups')
				.select('*', {})
				.eq('is_active', true)
				.executeAs<Array<MessageGroup>>()
			return response
		} catch (error) {		return {
			status: 500,
			data: [] as Array<MessageGroup>,
			error: new UniError(typeof error === 'string' ? error : error?.message ?? '获取群组失败'),
			origin: null,
			headers: {}
		} as AkReqResponse<Array<MessageGroup>>
		}
	}

	/**
	 * 获取群组成员
	 */
	static async getGroupMembers(groupId : string) : Promise<AkReqResponse<Array<GroupMember>>> {
		try {
			const response = await supa
				.from('ak_message_group_members')
				.select('*', {})
				.eq('group_id', groupId)
				.executeAs<Array<GroupMember>>()
			return response
		} catch (error) {		return {
			status: 500,
			data: [] as Array<GroupMember>,
			error: new UniError(typeof error === 'string' ? error : error?.message ?? '获取群组成员失败'),
			origin: null,
			headers: {}
		} as AkReqResponse<Array<GroupMember>>
		}
	}
}

/**
 * 创建标准错误响应
 */
function createErrorResponse<T>(data : T, errorMessage : string, status : number = 500) : AkReqResponse<T> {
	return {
		status: status,
		data: data,
		headers: {},
		error: new UniError(errorMessage),
		total: null,
		page: null,
		limit: null,
		hasmore: false,
		origin: null
	}
}