import { PresenceManager, UserPresenceRepository } from '@social-plus/sdk';

// Initialize presence tracking
const presenceManager = new PresenceManager();

// Enable presence for current user
await presenceManager.enable();

// Start automatic heartbeat
presenceManager.startHeartbeat();

// Track other users' presence
const userPresence = new UserPresenceRepository();
await userPresence.syncUserPresence(['user-1', 'user-2']);

// Listen for presence updates
userPresence.onPresenceChange((updates) => {
  updates.forEach(update => {
    console.log(`${update.userId} is ${update.isOnline ? 'online' : 'offline'}`);
  });
});

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Client Apps   │    │  Presence Hub   │    │  social.plus Core   │
│                 │    │                 │    │                 │
│ ┌─────────────┐ │    │ ┌─────────────┐ │    │ ┌─────────────┐ │
│ │Heartbeat    │ │───▶│ │Sync Manager │ │───▶│ │Presence     │ │
│ │Manager      │ │    │ │& Batching   │ │    │ │Database     │ │
│ └─────────────┘ │    │ └─────────────┘ │    │ └─────────────┘ │
│                 │    │                 │    │                 │
│ ┌─────────────┐ │    │ ┌─────────────┐ │    │ ┌─────────────┐ │
│ │Presence     │ │◀───│ │Real-time    │ │◀───│ │Event        │ │
│ │Observer     │ │    │ │Broadcaster  │ │    │ │Processor    │ │
│ └─────────────┘ │    │ └─────────────┘ │    │ └─────────────┘ │
└─────────────────┘    └─────────────────┘    └─────────────────┘

class BulkPresenceManager {
  private readonly MAX_SYNC_USERS = 20;
  private readonly MAX_SYNC_CHANNELS = 20;
  
  async syncMultipleUsers(userIds: string[]): Promise<void> {
    const batches = this.createBatches(userIds, this.MAX_SYNC_USERS);
    const presenceRepo = new UserPresenceRepository();
    
    for (const batch of batches) {
      await Promise.all(
        batch.map(userId => presenceRepo.syncUserPresence(userId))
      );
    }
  }
  
  async getOnlineUsersSnapshot(limit: number = 100): Promise<OnlineUsersSnapshot> {
    const presenceRepo = new UserPresenceRepository();
    const snapshot = await presenceRepo.getOnlineUsersSnapshot();
    
    return {
      users: snapshot.users.slice(0, limit),
      totalCount: await presenceRepo.getOnlineUsersCount(),
      canLoadMore: snapshot.canLoadMore,
      loadMore: () => snapshot.loadMore()
    };
  }
  
  private createBatches<T>(items: T[], batchSize: number): T[][] {
    const batches: T[][] = [];
    for (let i = 0; i < items.length; i += batchSize) {
      batches.push(items.slice(i, i + batchSize));
    }
    return batches;
  }
}

class SmartPresenceDetector {
  private activityTimer: NodeJS.Timeout | null = null;
  private isUserActive = true;
  private readonly IDLE_THRESHOLD = 5 * 60 * 1000; // 5 minutes

  constructor(private presenceManager: PresenceManager) {
    this.setupActivityListeners();
  }

  private setupActivityListeners(): void {
    // Browser/Web environment
    if (typeof window !== 'undefined') {
      ['mousedown', 'mousemove', 'keypress', 'scroll', 'touchstart', 'click'].forEach(event => {
        document.addEventListener(event, () => this.resetActivityTimer(), { passive: true });
      });
    }
  }

  private resetActivityTimer(): void {
    if (this.activityTimer) {
      clearTimeout(this.activityTimer);
    }

    // If user was idle, mark as active again
    if (!this.isUserActive) {
      this.isUserActive = true;
      this.presenceManager.startHeartbeat();
    }

    // Set new idle timer
    this.activityTimer = setTimeout(() => {
      this.isUserActive = false;
      this.presenceManager.stopHeartbeat();
    }, this.IDLE_THRESHOLD);
  }

  getActivityStatus(): { isActive: boolean; lastActivity: Date } {
    return {
      isActive: this.isUserActive,
      lastActivity: new Date(Date.now() - (this.isUserActive ? 0 : this.IDLE_THRESHOLD))
    };
  }

  cleanup(): void {
    if (this.activityTimer) {
      clearTimeout(this.activityTimer);
    }
  }
}

class PresenceAnalytics {
  private sessionStart: Date = new Date();
  private presenceEvents: PresenceEvent[] = [];

  trackPresenceChange(userId: string, isOnline: boolean, context?: string): void {
    this.presenceEvents.push({
      userId,
      isOnline,
      timestamp: new Date(),
      context,
      type: 'presence_change'
    });
  }

  getSessionStats(): SessionStats {
    const now = new Date();
    const sessionDuration = now.getTime() - this.sessionStart.getTime();
    
    return {
      sessionDuration,
      totalPresenceChanges: this.presenceEvents.length,
      uniqueUsersTracked: new Set(this.presenceEvents.map(e => e.userId)).size,
      averageOnlineTime: this.calculateAverageOnlineTime(),
      peakOnlineUsers: this.calculatePeakOnlineUsers()
    };
  }

  private calculateAverageOnlineTime(): number {
    const userSessions = new Map<string, { start: Date, end?: Date }[]>();
    
    this.presenceEvents.forEach(event => {
      if (!userSessions.has(event.userId)) {
        userSessions.set(event.userId, []);
      }
      
      const sessions = userSessions.get(event.userId)!;
      
      if (event.isOnline) {
        sessions.push({ start: event.timestamp });
      } else {
        const lastSession = sessions[sessions.length - 1];
        if (lastSession && !lastSession.end) {
          lastSession.end = event.timestamp;
        }
      }
    });

    // Calculate average session duration
    let totalDuration = 0;
    let sessionCount = 0;

    userSessions.forEach(sessions => {
      sessions.forEach(session => {
        if (session.end) {
          totalDuration += session.end.getTime() - session.start.getTime();
          sessionCount++;
        }
      });
    });

    return sessionCount > 0 ? totalDuration / sessionCount : 0;
  }

  private calculatePeakOnlineUsers(): number {
    const timeSlots = new Map<number, Set<string>>();
    const SLOT_DURATION = 60000; // 1 minute slots

    this.presenceEvents.forEach(event => {
      const slot = Math.floor(event.timestamp.getTime() / SLOT_DURATION);
      if (!timeSlots.has(slot)) {
        timeSlots.set(slot, new Set());
      }
      
      if (event.isOnline) {
        timeSlots.get(slot)!.add(event.userId);
      }
    });

    return Math.max(...Array.from(timeSlots.values()).map(users => users.size));
  }
}

interface PresenceEvent {
  userId: string;
  isOnline: boolean;
  timestamp: Date;
  context?: string;
  type: string;
}

interface SessionStats {
  sessionDuration: number;
  totalPresenceChanges: number;
  uniqueUsersTracked: number;
  averageOnlineTime: number;
  peakOnlineUsers: number;
}

const ChatPresenceIndicator: React.FC<{ userId: string }> = ({ userId }) => {
  const [presence, setPresence] = useState<UserPresence | null>(null);
  
  useEffect(() => {
    const repo = new UserPresenceRepository();
    repo.syncUserPresence(userId);
    
    const subscription = repo.getSyncingUserPresence()
      .subscribe(presences => {
        const userPresence = presences.find(p => p.userId === userId);
        setPresence(userPresence || null);
      });
    
    return () => {
      subscription.unsubscribe();
      repo.unsyncUserPresence(userId);
    };
  }, [userId]);
  
  return (
    <div className="presence-indicator">
      <div className={`status-dot ${presence?.isOnline ? 'online' : 'offline'}`} />
      <span className="status-text">
        {presence ? (presence.isOnline ? 'Online' : 'Offline') : 'Unknown'}
      </span>
    </div>
  );
};

const TeamPresenceBoard: React.FC<{ teamId: string }> = ({ teamId }) => {
  const [teamMembers, setTeamMembers] = useState<TeamMember[]>([]);
  const [presenceData, setPresenceData] = useState<Map<string, UserPresence>>(new Map());
  
  const organizedMembers = useMemo(() => {
    const online = teamMembers.filter(member => 
      presenceData.get(member.userId)?.isOnline
    );
    const offline = teamMembers.filter(member => 
      !presenceData.get(member.userId)?.isOnline
    );
    
    return { online, offline };
  }, [teamMembers, presenceData]);
  
  return (
    <div className="team-presence-board">
      <section className="online-section">
        <h3>Online ({organizedMembers.online.length})</h3>
        {organizedMembers.online.map(member => (
          <TeamMemberCard key={member.userId} member={member} isOnline={true} />
        ))}
      </section>
      
      <section className="offline-section">
        <h3>Offline ({organizedMembers.offline.length})</h3>
        {organizedMembers.offline.map(member => (
          <TeamMemberCard key={member.userId} member={member} isOnline={false} />
        ))}
      </section>
    </div>
  );
};

class LiveEventPresence {
  private participantPresence = new Map<string, ParticipantStatus>();
  
  async trackEventParticipants(eventId: string, participantIds: string[]): Promise<void> {
    const channelRepo = new ChannelPresenceRepository();
    
    // Sync channel presence for the event
    await channelRepo.syncChannelPresence(eventId);
    
    // Track individual participants
    const userRepo = new UserPresenceRepository();
    participantIds.forEach(id => userRepo.syncUserPresence(id));
    
    // Listen for presence changes
    userRepo.getSyncingUserPresence().subscribe(presences => {
      presences.forEach(presence => {
        this.participantPresence.set(presence.userId, {
          isOnline: presence.isOnline,
          lastSeen: presence.lastHeartbeat,
          engagementLevel: this.calculateEngagement(presence)
        });
      });
      
      this.notifyPresenceUpdate();
    });
  }
  
  private calculateEngagement(presence: UserPresence): 'high' | 'medium' | 'low' {
    const timeSinceLastSeen = Date.now() - presence.lastHeartbeat;
    
    if (timeSinceLastSeen < 30000) return 'high';    // < 30s
    if (timeSinceLastSeen < 120000) return 'medium'; // < 2min
    return 'low';
  }
  
  getEventStats(): EventPresenceStats {
    const participants = Array.from(this.participantPresence.values());
    
    return {
      totalParticipants: participants.length,
      onlineCount: participants.filter(p => p.isOnline).length,
      highEngagement: participants.filter(p => p.engagementLevel === 'high').length,
      mediumEngagement: participants.filter(p => p.engagementLevel === 'medium').length,
      lowEngagement: participants.filter(p => p.engagementLevel === 'low').length
    };
  }
}