import { NextRequest, NextResponse } from 'next/server';
import { getFirestore } from 'firebase-admin/firestore';
import { initializeApp, getApps, cert, applicationDefault } from 'firebase-admin/app';
import * as fs from 'fs';
import * as path from 'path';
import { membershipPlans } from '../../../../lib/membershipPlans';
import { MembershipTier } from '../../../../types/membership';

// Initialize Firebase Admin SDK
let adminDb: any = null;
try {
  if (getApps().length === 0) {
    let initialized = false;
    
    // Method 1: Try service account key from environment variable
    const serviceAccountKey = process.env.FIREBASE_SERVICE_ACCOUNT_KEY;
    if (serviceAccountKey) {
      try {
        const serviceAccount = JSON.parse(serviceAccountKey);
        initializeApp({
          credential: cert(serviceAccount),
        });
        adminDb = getFirestore();
        initialized = true;
      } catch (e) {
        console.error('Error parsing FIREBASE_SERVICE_ACCOUNT_KEY:', e);
      }
    }
    
    // Method 2: Try service account file
    if (!initialized) {
      const possiblePaths = [
        process.env.FIREBASE_SERVICE_ACCOUNT_PATH,
        './firebase-service-account.json',
        path.join(process.cwd(), 'firebase-service-account.json'),
      ].filter(Boolean);
      
      for (const filePath of possiblePaths) {
        try {
          const resolvedPath = path.resolve(process.cwd(), filePath!);
          if (fs.existsSync(resolvedPath)) {
            const fileContent = fs.readFileSync(resolvedPath, 'utf8');
            const serviceAccount = JSON.parse(fileContent);
            
            if (!serviceAccount.private_key || !serviceAccount.client_email) {
              throw new Error('Invalid service account file - missing required fields');
            }
            
            initializeApp({
              credential: cert(serviceAccount),
            });
            adminDb = getFirestore();
            initialized = true;
            break;
          }
        } catch (e: any) {
          console.error(`Error loading service account from ${filePath}:`, e.message);
        }
      }
    }
    
    // Method 3: Try Application Default Credentials
    if (!initialized) {
      try {
        initializeApp({
          credential: applicationDefault(),
          projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID || 'wolna-glowa',
        });
        adminDb = getFirestore();
        initialized = true;
      } catch (e: any) {
        console.warn('Application Default Credentials not available:', e.message);
      }
    }
    
    // Method 4: Fallback
    if (!initialized) {
      initializeApp({
        projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID || 'wolna-glowa',
      });
      adminDb = getFirestore();
    }
  } else {
    adminDb = getFirestore();
  }
} catch (error) {
  console.error('Firebase Admin initialization error:', error);
}

interface PlanStats {
  planId: string;
  planName: string;
  price: number;
  currency: string;
  totalSubscribers: number;
  activeSubscribers: number;
  canceledSubscribers: number;
  pastDueSubscribers: number;
  trialingSubscribers: number;
  monthlyRevenue: number;
  annualRevenue: number;
  totalRevenue: number;
  averageSubscriptionDuration: number; // in days
  churnRate: number; // percentage
  growthRate: number; // percentage (new subscriptions this month vs last month)
  newSubscriptionsThisMonth: number;
  newSubscriptionsLastMonth: number;
}

export async function GET(request: NextRequest) {
  try {
    if (!adminDb) {
      return NextResponse.json({
        success: false,
        error: 'Firebase Admin SDK nie został zainicjalizowany',
        data: [],
      }, { status: 500 });
    }

    // Fetch all subscriptions from Firestore
    // Check both 'subscriptions' and 'users' collections (subscriptions might be stored in user documents)
    let allSubscriptions: any[] = [];
    
    try {
      const subscriptionsSnapshot = await adminDb.collection('subscriptions').get();
      console.log(`📊 Found ${subscriptionsSnapshot.size} documents in 'subscriptions' collection`);
      subscriptionsSnapshot.forEach((doc: any) => {
        const data = doc.data();
        allSubscriptions.push({
          id: doc.id,
          userId: data.userId || `sub_${doc.id}`,
          plan: data.plan || 'ODDECH',
          status: data.status || 'active',
          ...data,
          // Convert Firestore timestamps to Date objects
          currentPeriodStart: data.currentPeriodStart?.toDate?.() || data.currentPeriodStart || new Date(),
          currentPeriodEnd: data.currentPeriodEnd?.toDate?.() || data.currentPeriodEnd || new Date(),
          createdAt: data.createdAt?.toDate?.() || data.createdAt || new Date(),
          updatedAt: data.updatedAt?.toDate?.() || data.updatedAt || new Date(),
        });
      });
    } catch (error: any) {
      console.log('No subscriptions collection found or error:', error.message);
    }

    // Also check users collection for subscription data
    try {
      const usersSnapshot = await adminDb.collection('users').get();
      console.log(`👥 Found ${usersSnapshot.size} users in 'users' collection`);
      let usersWithSubscriptions = 0;
      usersSnapshot.forEach((doc: any) => {
        const userData = doc.data();
        if (userData.subscription || userData.membershipTier) {
          usersWithSubscriptions++;
          allSubscriptions.push({
            id: `user_${doc.id}`,
            userId: doc.id,
            plan: userData.membershipTier || userData.subscription?.plan || 'ODDECH',
            status: userData.subscription?.status || (userData.membershipTier ? 'active' : 'canceled'),
            currentPeriodStart: userData.subscription?.currentPeriodStart?.toDate?.() || new Date(),
            currentPeriodEnd: userData.subscription?.currentPeriodEnd?.toDate?.() || new Date(),
            createdAt: userData.subscription?.createdAt?.toDate?.() || userData.createdAt?.toDate?.() || new Date(),
            updatedAt: userData.subscription?.updatedAt?.toDate?.() || userData.updatedAt?.toDate?.() || new Date(),
          });
        }
      });
      console.log(`✅ Found ${usersWithSubscriptions} users with subscription data`);
    } catch (error: any) {
      console.log('Error fetching users:', error.message);
    }

    console.log(`📈 Total subscriptions found: ${allSubscriptions.length}`);

    // Calculate statistics for each plan
    const planStats: PlanStats[] = membershipPlans.map((plan) => {
      const planSubscriptions = allSubscriptions.filter(
        (sub) => sub.plan === plan.name
      );

      const now = new Date();
      const thisMonthStart = new Date(now.getFullYear(), now.getMonth(), 1);
      const lastMonthStart = new Date(now.getFullYear(), now.getMonth() - 1, 1);
      const lastMonthEnd = new Date(now.getFullYear(), now.getMonth(), 0);

      const activeSubs = planSubscriptions.filter(
        (sub) => sub.status === 'active' || sub.status === 'trialing'
      );
      const pendingSubs = planSubscriptions.filter(
        (sub) => sub.status === 'pending'
      );
      const canceledSubs = planSubscriptions.filter(
        (sub) => sub.status === 'canceled'
      );
      const pastDueSubs = planSubscriptions.filter(
        (sub) => sub.status === 'past_due'
      );
      const trialingSubs = planSubscriptions.filter(
        (sub) => sub.status === 'trialing'
      );

      const newSubscriptionsThisMonth = planSubscriptions.filter((sub) => {
        const createdAt = sub.createdAt instanceof Date ? sub.createdAt : new Date(sub.createdAt);
        return createdAt >= thisMonthStart;
      }).length;

      const newSubscriptionsLastMonth = planSubscriptions.filter((sub) => {
        const createdAt = sub.createdAt instanceof Date ? sub.createdAt : new Date(sub.createdAt);
        return createdAt >= lastMonthStart && createdAt < thisMonthStart;
      }).length;

      const growthRate =
        newSubscriptionsLastMonth > 0
          ? ((newSubscriptionsThisMonth - newSubscriptionsLastMonth) / newSubscriptionsLastMonth) * 100
          : newSubscriptionsThisMonth > 0 ? 100 : 0;

      // Calculate churn rate (canceled / total active in last period)
      const totalActive = activeSubs.length + canceledSubs.length;
      const churnRate = totalActive > 0 ? (canceledSubs.length / totalActive) * 100 : 0;

      // Calculate average subscription duration
      const durations = activeSubs
        .map((sub) => {
          const start = sub.currentPeriodStart instanceof Date 
            ? sub.currentPeriodStart 
            : new Date(sub.currentPeriodStart);
          const end = sub.currentPeriodEnd instanceof Date 
            ? sub.currentPeriodEnd 
            : new Date(sub.currentPeriodEnd);
          return (end.getTime() - start.getTime()) / (1000 * 60 * 60 * 24); // days
        })
        .filter((d) => !isNaN(d) && d > 0);

      const averageDuration =
        durations.length > 0
          ? durations.reduce((a, b) => a + b, 0) / durations.length
          : 0;

      // Calculate revenue - include active and pending subscriptions
      // For pending, we show potential revenue
      const activeAndPendingSubs = [...activeSubs, ...pendingSubs];
      const monthlyRevenue = activeSubs.length * plan.price;
      const potentialMonthlyRevenue = activeAndPendingSubs.length * plan.price; // Includes pending
      const annualRevenue = monthlyRevenue * 12;
      const potentialAnnualRevenue = potentialMonthlyRevenue * 12;
      
      // Total revenue from active subscriptions only
      const totalRevenue = planSubscriptions
        .filter((sub) => sub.status === 'active')
        .reduce((sum, sub) => {
          // Estimate total revenue based on subscription duration
          const start = sub.currentPeriodStart instanceof Date 
            ? sub.currentPeriodStart 
            : new Date(sub.currentPeriodStart);
          const monthsActive = Math.max(1, Math.floor((now.getTime() - start.getTime()) / (1000 * 60 * 60 * 24 * 30)));
          return sum + (plan.price * monthsActive);
        }, 0);
      
      // Potential total revenue (including pending)
      const potentialTotalRevenue = totalRevenue + (pendingSubs.length * plan.price);

      return {
        planId: plan.id,
        planName: plan.name,
        price: plan.price,
        currency: plan.currency,
        totalSubscribers: planSubscriptions.length,
        activeSubscribers: activeSubs.length,
        pendingSubscribers: pendingSubs.length,
        canceledSubscribers: canceledSubs.length,
        pastDueSubscribers: pastDueSubs.length,
        trialingSubscribers: trialingSubs.length,
        monthlyRevenue,
        potentialMonthlyRevenue,
        annualRevenue,
        potentialAnnualRevenue,
        totalRevenue,
        potentialTotalRevenue,
        averageSubscriptionDuration: Math.round(averageDuration),
        churnRate: Math.round(churnRate * 100) / 100,
        growthRate: Math.round(growthRate * 100) / 100,
        newSubscriptionsThisMonth,
        newSubscriptionsLastMonth,
      };
    });

    // Calculate overall statistics
    const totalSubscribers = allSubscriptions.length;
    const totalActiveSubscribers = allSubscriptions.filter(
      (sub) => sub.status === 'active' || sub.status === 'trialing'
    ).length;
    const totalPendingSubscribers = allSubscriptions.filter(
      (sub) => sub.status === 'pending'
    ).length;
    const totalMonthlyRevenue = planStats.reduce((sum, plan) => sum + plan.monthlyRevenue, 0);
    const totalPotentialMonthlyRevenue = planStats.reduce((sum, plan) => sum + (plan.potentialMonthlyRevenue || plan.monthlyRevenue), 0);
    const totalAnnualRevenue = planStats.reduce((sum, plan) => sum + plan.annualRevenue, 0);
    const totalPotentialAnnualRevenue = planStats.reduce((sum, plan) => sum + (plan.potentialAnnualRevenue || plan.annualRevenue), 0);

    return NextResponse.json({
      success: true,
      data: {
        plans: planStats,
        summary: {
          totalSubscribers,
          totalActiveSubscribers,
          totalPendingSubscribers,
          totalMonthlyRevenue,
          totalPotentialMonthlyRevenue,
          totalAnnualRevenue,
          totalPotentialAnnualRevenue,
        },
        metadata: {
          totalSubscriptionsFound: allSubscriptions.length,
          dataSource: allSubscriptions.length > 0 ? 'firestore' : 'empty',
        },
      },
    });
  } catch (error: any) {
    console.error('Error fetching subscription statistics:', error);
    return NextResponse.json(
      {
        success: false,
        error: error.message || 'Błąd podczas pobierania statystyk subskrypcji',
      },
      { status: 500 }
    );
  }
}