import { Gitlab } from '@gitbeaker/rest';
import { GitLabActivity } from '../types/index.js';
import { startOfDay, endOfDay } from 'date-fns';

export class GitLabIntegration {
  private client: InstanceType<typeof Gitlab> | null = null;
  private userId: number | null = null;

  async initialize(token: string, gitlabUrl: string = 'https://gitlab.com'): Promise<void> {
    this.client = new Gitlab({
      token,
      host: gitlabUrl,
    });

    // Get current user ID
    const user = await this.client.Users.showCurrentUser();
    this.userId = user.id;
  }

  async getActivityForDate(date: Date): Promise<GitLabActivity> {
    if (!this.client || !this.userId) {
      throw new Error('GitLab client not initialized');
    }

    const dayStart = startOfDay(date);
    const dayEnd = endOfDay(date);

    const activity: GitLabActivity = {
      date,
      commits: [],
      mergeRequests: [],
      issues: [],
    };

    try {
      // Get user's events for the day
      // GitLab API: after means >= date, before means <= date
      const events = await this.client.Events.all({
        after: dayStart.toISOString().split('T')[0],
      });

      for (const event of events) {
        if (event.author_id !== this.userId) continue;

        // Filter events to only include those within the target day
        const eventDate = new Date(event.created_at as string);
        if (eventDate < dayStart || eventDate > dayEnd) continue;

        const projectName = event.project_id && typeof event.project_id === 'number'
          ? await this.getProjectName(event.project_id)
          : 'Unknown';

        switch (event.action_name) {
          case 'pushed to':
          case 'pushed new':
            if (event.push_data && typeof event.push_data === 'object') {
              const pushData = event.push_data as any;
              activity.commits.push({
                message: String(pushData.commit_title || 'Commit'),
                project: projectName,
                branch: String(pushData.ref || 'unknown'),
              });
            }
            break;

          case 'opened':
            if (event.target_type === 'MergeRequest') {
              activity.mergeRequests.push({
                action: 'created',
                title: String(event.target_title || 'MR'),
                project: projectName,
              });
            } else if (event.target_type === 'Issue') {
              activity.issues.push({
                action: 'status_changed',
                title: String(event.target_title || 'Issue'),
                project: projectName,
                details: 'opened',
              });
            }
            break;

          case 'commented on':
            if (event.target_type === 'MergeRequest') {
              activity.mergeRequests.push({
                action: 'commented',
                title: String(event.target_title || 'MR'),
                project: projectName,
              });
            } else if (event.target_type === 'Issue') {
              activity.issues.push({
                action: 'commented',
                title: String(event.target_title || 'Issue'),
                project: projectName,
              });
            }
            break;

          case 'accepted':
            if (event.target_type === 'MergeRequest') {
              activity.mergeRequests.push({
                action: 'approved',
                title: String(event.target_title || 'MR'),
                project: projectName,
              });
            }
            break;

          case 'approved':
            if (event.target_type === 'MergeRequest') {
              activity.mergeRequests.push({
                action: 'approved',
                title: String(event.target_title || 'MR'),
                project: projectName,
              });
            }
            break;
        }
      }

      // Also fetch commits directly for more detailed information
      await this.fetchCommitsForDate(date, activity);

      // Fetch MR reviews
      await this.fetchMergeRequestActivity(date, activity);

    } catch (error) {
      console.error('Error fetching GitLab activity:', error);
    }

    return activity;
  }

  private async fetchCommitsForDate(date: Date, activity: GitLabActivity): Promise<void> {
    if (!this.client || !this.userId) return;

    try {
      // Get all projects the user has access to
      const projects = await this.client.Projects.all({
        membership: true,
        simple: true,
        perPage: 100,
      });

      const dayStart = startOfDay(date);
      const dayEnd = endOfDay(date);

      for (const project of projects) {
        try {
          const commits = await this.client.Commits.all(project.id, {
            since: dayStart.toISOString(),
            until: dayEnd.toISOString(),
            author: await this.getCurrentUserEmail(),
          });

          for (const commit of commits) {
            // Avoid duplicates
            const exists = activity.commits.some(c => c.message === commit.title);
            if (!exists) {
              activity.commits.push({
                message: commit.title,
                project: project.name,
                branch: 'main', // GitLab API doesn't always provide branch in commit list
              });
            }
          }
        } catch (error) {
          // Skip projects we can't access
          continue;
        }
      }
    } catch (error) {
      console.error('Error fetching commits:', error);
    }
  }

  private async fetchMergeRequestActivity(date: Date, activity: GitLabActivity): Promise<void> {
    if (!this.client || !this.userId) return;

    try {
      const dayStart = startOfDay(date);
      const dayEnd = endOfDay(date);

      // Get MRs created by user
      const createdMRs = await this.client.MergeRequests.all({
        authorId: this.userId,
        createdAfter: dayStart.toISOString(),
        createdBefore: dayEnd.toISOString(),
        scope: 'all',
      });

      for (const mr of createdMRs) {
        const projectId = typeof mr.project_id === 'number' ? mr.project_id : 0;
        const projectName = await this.getProjectName(projectId);
        activity.mergeRequests.push({
          action: 'created',
          title: mr.title,
          project: projectName,
        });
      }

      // Get MRs where user is reviewer
      const reviewMRs = await this.client.MergeRequests.all({
        reviewerId: this.userId,
        updatedAfter: dayStart.toISOString(),
        updatedBefore: dayEnd.toISOString(),
        scope: 'all',
      });

      for (const mr of reviewMRs) {
        const projectId = typeof mr.project_id === 'number' ? mr.project_id : 0;
        const projectName = await this.getProjectName(projectId);
        // Check if already added
        const exists = activity.mergeRequests.some(
          m => m.title === mr.title && m.project === projectName
        );
        if (!exists) {
          activity.mergeRequests.push({
            action: 'reviewed',
            title: mr.title,
            project: projectName,
          });
        }
      }
    } catch (error) {
      console.error('Error fetching MR activity:', error);
    }
  }

  private projectNameCache = new Map<number, string>();

  private async getProjectName(projectId: number): Promise<string> {
    if (this.projectNameCache.has(projectId)) {
      return this.projectNameCache.get(projectId)!;
    }

    try {
      const project = await this.client!.Projects.show(projectId);
      this.projectNameCache.set(projectId, project.name);
      return project.name;
    } catch {
      return `Project ${projectId}`;
    }
  }

  private async getCurrentUserEmail(): Promise<string> {
    if (!this.client) throw new Error('Client not initialized');
    const user = await this.client.Users.showCurrentUser();
    return user.email;
  }
}