import { router, protectedProcedure } from '../_core/trpc.ts';
import { z } from 'zod';
import { observable } from '@trpc/server/observable';

/**
 * Share Rewards WebSocket Router
 * Real-time notifications for shared rewards and social interactions
 */
export const shareRewardsWebSocketRouter = router({
  /**
   * Subscribe to share reward notifications
   */
  subscribeShareRewards: protectedProcedure.subscription(({ ctx }) => {
    return observable<any>((emit) => {
      // Simulate real-time share reward notifications
      const interval = setInterval(() => {
        emit.next({
          type: 'share_reward',
          playerId: ctx.user.id,
          reward: {
            type: 'sc_bonus',
            amount: Math.floor(Math.random() * 100) + 10,
            source: 'friend_referral',
            friendName: 'Friend Name',
          },
          timestamp: new Date(),
        });
      }, 30000);

      return () => {
        clearInterval(interval);
      };
    });
  }),

  /**
   * Subscribe to friend activity notifications
   */
  subscribeFriendActivity: protectedProcedure.subscription(({ ctx }) => {
    return observable<any>((emit) => {
      const interval = setInterval(() => {
        emit.next({
          type: 'friend_activity',
          friendName: 'Friend Name',
          activity: 'won_big',
          amount: Math.floor(Math.random() * 5000) + 500,
          gameTitle: 'Crystal Cascade',
          timestamp: new Date(),
        });
      }, 45000);

      return () => {
        clearInterval(interval);
      };
    });
  }),

  /**
   * Subscribe to tournament updates
   */
  subscribeTournamentUpdates: protectedProcedure
    .input(z.object({ tournamentId: z.string() }))
    .subscription(({ input }) => {
      return observable<any>((emit) => {
        const interval = setInterval(() => {
          emit.next({
            tournamentId: input.tournamentId,
            type: 'rank_change',
            newRank: Math.floor(Math.random() * 100) + 1,
            scoreChange: Math.floor(Math.random() * 1000),
            timestamp: new Date(),
          });
        }, 10000);

        return () => {
          clearInterval(interval);
        };
      });
    }),

  /**
   * Subscribe to bonus notifications
   */
  subscribeBonusNotifications: protectedProcedure.subscription(({ ctx }) => {
    return observable<any>((emit) => {
      const interval = setInterval(() => {
        const bonusTypes = ['daily_bonus', 'weekly_bonus', 'milestone_bonus', 'referral_bonus'];
        emit.next({
          type: 'bonus_available',
          bonusType: bonusTypes[Math.floor(Math.random() * bonusTypes.length)],
          amount: Math.floor(Math.random() * 500) + 50,
          expiresIn: Math.floor(Math.random() * 86400) + 3600,
          timestamp: new Date(),
        });
      }, 60000);

      return () => {
        clearInterval(interval);
      };
    });
  }),

  /**
   * Subscribe to promotion notifications
   */
  subscribePromotions: protectedProcedure.subscription(({ ctx }) => {
    return observable<any>((emit) => {
      const interval = setInterval(() => {
        emit.next({
          type: 'promotion',
          title: 'Weekend Bonus Spree',
          description: 'Get 2x multiplier on all wins this weekend',
          startDate: new Date(),
          endDate: new Date(Date.now() + 172800000),
          timestamp: new Date(),
        });
      }, 120000);

      return () => {
        clearInterval(interval);
      };
    });
  }),

  /**
   * Subscribe to achievement unlocked notifications
   */
  subscribeAchievements: protectedProcedure.subscription(({ ctx }) => {
    return observable<any>((emit) => {
      const interval = setInterval(() => {
        emit.next({
          type: 'achievement_unlocked',
          achievementId: `achievement_${Date.now()}`,
          title: 'High Roller',
          description: 'Wager $1,000 in a single session',
          reward: { sc: 100, badge: 'high_roller' },
          timestamp: new Date(),
        });
      }, 90000);

      return () => {
        clearInterval(interval);
      };
    });
  }),

  /**
   * Subscribe to VIP tier upgrade notifications
   */
  subscribeVIPUpgrades: protectedProcedure.subscription(({ ctx }) => {
    return observable<any>((emit) => {
      const interval = setInterval(() => {
        emit.next({
          type: 'vip_tier_upgrade',
          oldTier: 'gold',
          newTier: 'platinum',
          benefits: {
            cashback: 10,
            freeSpins: 300,
            monthlyReward: 750,
          },
          timestamp: new Date(),
        });
      }, 300000);

      return () => {
        clearInterval(interval);
      };
    });
  }),

  /**
   * Get share reward history
   */
  getShareRewardHistory: protectedProcedure
    .input(z.object({ limit: z.number().default(50) }))
    .query(async ({ ctx, input }) => {
      return [
        { date: '2024-04-20', type: 'referral', amount: 100, source: 'Friend 1' },
        { date: '2024-04-18', type: 'social_share', amount: 50, source: 'Facebook' },
        { date: '2024-04-15', type: 'referral', amount: 100, source: 'Friend 2' },
        { date: '2024-04-10', type: 'tournament_share', amount: 200, source: 'Tournament' },
      ].slice(0, input.limit);
    }),

  /**
   * Get friend leaderboard
   */
  getFriendLeaderboard: protectedProcedure
    .input(z.object({ limit: z.number().default(10) }))
    .query(async ({ ctx, input }) => {
      return [
        { rank: 1, friendName: 'Friend 1', score: 50000, status: 'online' },
        { rank: 2, friendName: 'Friend 2', score: 45000, status: 'offline' },
        { rank: 3, friendName: 'Friend 3', score: 40000, status: 'online' },
      ].slice(0, input.limit);
    }),

  /**
   * Share game result
   */
  shareGameResult: protectedProcedure
    .input(
      z.object({
        gameId: z.string(),
        result: z.object({
          winAmount: z.number(),
          multiplier: z.number(),
          symbols: z.array(z.number()),
        }),
        platform: z.enum(['facebook', 'twitter', 'whatsapp', 'email']),
      })
    )
    .mutation(async ({ ctx, input }) => {
      return {
        success: true,
        message: `Game result shared to ${input.platform}`,
        reward: { sc: 50 },
      };
    }),

  /**
   * Invite friend
   */
  inviteFriend: protectedProcedure
    .input(
      z.object({
        friendEmail: z.string().email(),
        message: z.string().optional(),
      })
    )
    .mutation(async ({ ctx, input }) => {
      return {
        success: true,
        message: 'Invitation sent successfully',
        referralCode: `REF_${ctx.user.id}_${Date.now()}`,
      };
    }),

  /**
   * Get referral statistics
   */
  getReferralStats: protectedProcedure.query(async ({ ctx }) => {
    return {
      totalReferrals: 12,
      activeReferrals: 8,
      totalEarned: 1200,
      pendingRewards: 300,
      topReferral: {
        friendName: 'Friend 1',
        joinDate: '2024-04-10',
        earned: 500,
      },
    };
  }),

  /**
   * Get social sharing statistics
   */
  getSocialStats: protectedProcedure.query(async ({ ctx }) => {
    return {
      totalShares: 45,
      sharesByPlatform: {
        facebook: 20,
        twitter: 15,
        whatsapp: 8,
        email: 2,
      },
      totalRewardsFromShares: 450,
      thisMonthShares: 12,
    };
  }),
});