const { TaskEvent } = require('../models');

class TaskEventService {
    /**
     * Log a task event
     * @param {Object} eventData - Event data
     * @param {number} eventData.taskId - Task ID
     * @param {number} eventData.userId - User ID
     * @param {string} eventData.eventType - Type of event
     * @param {string} eventData.fieldName - Field that changed (optional)
     * @param {any} eventData.oldValue - Old value (optional)
     * @param {any} eventData.newValue - New value (optional)
     * @param {Object} eventData.metadata - Additional metadata (optional)
     */
    static async logEvent({
        taskId,
        userId,
        eventType,
        fieldName = null,
        oldValue = null,
        newValue = null,
        metadata = {},
    }) {
        try {
            // Add source to metadata if not provided
            if (!metadata.source) {
                metadata.source = 'web';
            }

            const event = await TaskEvent.create({
                task_id: taskId,
                user_id: userId,
                event_type: eventType,
                field_name: fieldName,
                old_value: oldValue
                    ? { [fieldName || 'value']: oldValue }
                    : null,
                new_value: newValue
                    ? { [fieldName || 'value']: newValue }
                    : null,
                metadata: metadata,
            });

            return event;
        } catch (error) {
            console.error('Error logging task event:', error);
            throw error;
        }
    }

    /**
     * Log task creation event
     */
    static async logTaskCreated(taskId, userId, taskData, metadata = {}) {
        return await this.logEvent({
            taskId,
            userId,
            eventType: 'created',
            newValue: taskData,
            metadata: { ...metadata, action: 'task_created' },
        });
    }

    /**
     * Log status change event
     */
    static async logStatusChange(
        taskId,
        userId,
        oldStatus,
        newStatus,
        metadata = {}
    ) {
        const eventType =
            newStatus === 2
                ? 'completed'
                : newStatus === 3
                  ? 'archived'
                  : 'status_changed';

        return await this.logEvent({
            taskId,
            userId,
            eventType,
            fieldName: 'status',
            oldValue: oldStatus,
            newValue: newStatus,
            metadata: { ...metadata, action: 'status_change' },
        });
    }

    /**
     * Log priority change event
     */
    static async logPriorityChange(
        taskId,
        userId,
        oldPriority,
        newPriority,
        metadata = {}
    ) {
        return await this.logEvent({
            taskId,
            userId,
            eventType: 'priority_changed',
            fieldName: 'priority',
            oldValue: oldPriority,
            newValue: newPriority,
            metadata: { ...metadata, action: 'priority_change' },
        });
    }

    /**
     * Log due date change event
     */
    static async logDueDateChange(
        taskId,
        userId,
        oldDueDate,
        newDueDate,
        metadata = {}
    ) {
        return await this.logEvent({
            taskId,
            userId,
            eventType: 'due_date_changed',
            fieldName: 'due_date',
            oldValue: oldDueDate,
            newValue: newDueDate,
            metadata: { ...metadata, action: 'due_date_change' },
        });
    }

    /**
     * Log project change event
     */
    static async logProjectChange(
        taskId,
        userId,
        oldProjectId,
        newProjectId,
        metadata = {}
    ) {
        return await this.logEvent({
            taskId,
            userId,
            eventType: 'project_changed',
            fieldName: 'project_id',
            oldValue: oldProjectId,
            newValue: newProjectId,
            metadata: { ...metadata, action: 'project_change' },
        });
    }

    /**
     * Log task name change event
     */
    static async logNameChange(
        taskId,
        userId,
        oldName,
        newName,
        metadata = {}
    ) {
        return await this.logEvent({
            taskId,
            userId,
            eventType: 'name_changed',
            fieldName: 'name',
            oldValue: oldName,
            newValue: newName,
            metadata: { ...metadata, action: 'name_change' },
        });
    }

    /**
     * Log description change event
     */
    static async logDescriptionChange(
        taskId,
        userId,
        oldDescription,
        newDescription,
        metadata = {}
    ) {
        return await this.logEvent({
            taskId,
            userId,
            eventType: 'description_changed',
            fieldName: 'description',
            oldValue: oldDescription,
            newValue: newDescription,
            metadata: { ...metadata, action: 'description_change' },
        });
    }

    /**
     * Log multiple field changes at once
     */
    static async logTaskUpdate(taskId, userId, changes, metadata = {}) {
        const events = [];

        for (const [fieldName, { oldValue, newValue }] of Object.entries(
            changes
        )) {
            // Skip if values are the same
            if (oldValue === newValue) continue;

            let eventType;
            switch (fieldName) {
                case 'status':
                    eventType =
                        newValue === 2
                            ? 'completed'
                            : newValue === 3
                              ? 'archived'
                              : 'status_changed';
                    break;
                default:
                    eventType = `${fieldName}_changed`;
            }

            const event = await this.logEvent({
                taskId,
                userId,
                eventType,
                fieldName,
                oldValue,
                newValue,
                metadata: { ...metadata, action: 'bulk_update' },
            });

            events.push(event);
        }

        return events;
    }

    /**
     * Get task timeline (all events for a task)
     */
    static async getTaskTimeline(taskId) {
        return await TaskEvent.findAll({
            where: { task_id: taskId },
            order: [['created_at', 'ASC']],
            include: [
                {
                    model: require('../models').User,
                    as: 'User',
                    attributes: ['id', 'name', 'email'],
                },
            ],
        });
    }

    /**
     * Get task completion metrics
     */
    static async getTaskCompletionTime(taskId) {
        const events = await TaskEvent.findAll({
            where: {
                task_id: taskId,
                event_type: ['status_changed', 'created', 'completed'],
            },
            order: [['created_at', 'ASC']],
        });

        if (events.length === 0) return null;

        // Find when task was started (moved to in_progress or created)
        const startEvent = events.find(
            (e) =>
                e.event_type === 'created' ||
                (e.event_type === 'status_changed' && e.new_value?.status === 1) // in_progress
        );

        // Find when task was completed
        const completedEvent = events.find(
            (e) =>
                e.event_type === 'completed' ||
                (e.event_type === 'status_changed' && e.new_value?.status === 2) // done
        );

        if (!startEvent || !completedEvent) return null;

        const startTime = new Date(startEvent.created_at);
        const endTime = new Date(completedEvent.created_at);

        return {
            task_id: taskId,
            started_at: startTime,
            completed_at: endTime,
            duration_ms: endTime - startTime,
            duration_hours: (endTime - startTime) / (1000 * 60 * 60),
            duration_days: (endTime - startTime) / (1000 * 60 * 60 * 24),
        };
    }

    /**
     * Get user productivity metrics
     */
    static async getUserProductivityMetrics(
        userId,
        startDate = null,
        endDate = null
    ) {
        const whereClause = { user_id: userId };

        if (startDate && endDate) {
            whereClause.created_at = {
                [require('sequelize').Op.between]: [startDate, endDate],
            };
        }

        const events = await TaskEvent.findAll({
            where: whereClause,
            order: [['created_at', 'ASC']],
        });

        // Calculate metrics
        const metrics = {
            total_events: events.length,
            tasks_created: events.filter((e) => e.event_type === 'created')
                .length,
            tasks_completed: events.filter((e) => e.event_type === 'completed')
                .length,
            status_changes: events.filter(
                (e) => e.event_type === 'status_changed'
            ).length,
            average_completion_time: null,
            completion_times: [],
        };

        // Calculate completion times for all completed tasks
        const completedTasks = events.filter(
            (e) => e.event_type === 'completed'
        );
        const completionTimes = [];

        for (const completedEvent of completedTasks) {
            const taskCompletion = await this.getTaskCompletionTime(
                completedEvent.task_id
            );
            if (taskCompletion) {
                completionTimes.push(taskCompletion);
            }
        }

        if (completionTimes.length > 0) {
            const totalHours = completionTimes.reduce(
                (sum, ct) => sum + ct.duration_hours,
                0
            );
            metrics.average_completion_time =
                totalHours / completionTimes.length;
            metrics.completion_times = completionTimes;
        }

        return metrics;
    }

    /**
     * Get task activity summary for a date range
     */
    static async getTaskActivitySummary(userId, startDate, endDate) {
        const events = await TaskEvent.findAll({
            where: {
                user_id: userId,
                created_at: {
                    [require('sequelize').Op.between]: [startDate, endDate],
                },
            },
            attributes: [
                'event_type',
                [
                    require('sequelize').fn(
                        'COUNT',
                        require('sequelize').col('id')
                    ),
                    'count',
                ],
                [
                    require('sequelize').fn(
                        'DATE',
                        require('sequelize').col('created_at')
                    ),
                    'date',
                ],
            ],
            group: ['event_type', 'date'],
            order: [['date', 'ASC']],
        });

        return events;
    }

    /**
     * Get count of how many times a task has been moved to today
     */
    static async getTaskTodayMoveCount(taskId) {
        const { Op } = require('sequelize');

        const count = await TaskEvent.count({
            where: {
                task_id: taskId,
                event_type: 'today_changed',
                new_value: {
                    [Op.like]: '%"today":true%',
                },
            },
        });

        return count;
    }
}

module.exports = TaskEventService;