adopt-a-street/backend/models/PointTransaction.js

const couchdbService = require("../services/couchdbService");

class PointTransaction {
  static async create(transactionData) {
    try {
      const transaction = {
        _id: `point_transaction_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
        type: 'point_transaction',
        user: transactionData.user,
        amount: transactionData.amount,
        transactionType: transactionData.transactionType,
        description: transactionData.description,
        relatedEntity: transactionData.relatedEntity || null,
        balanceAfter: transactionData.balanceAfter,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString()
      };

      const result = await couchdbService.insert(transaction);
      return { ...transaction, _rev: result.rev };
    } catch (error) {
      console.error('Error creating point transaction:', error);
      throw error;
    }
  }

  static async findByUser(userId, limit = 50, skip = 0) {
    try {
      const result = await couchdbService.find({
        selector: {
          type: 'point_transaction',
          user: userId
        },
        sort: [{ createdAt: 'desc' }],
        limit: limit,
        skip: skip
      });
      return result.docs;
    } catch (error) {
      console.error('Error finding point transactions by user:', error);
      throw error;
    }
  }

  static async findByType(transactionType, limit = 50, skip = 0) {
    try {
      const result = await couchdbService.find({
        selector: {
          type: 'point_transaction',
          transactionType: transactionType
        },
        sort: [{ createdAt: 'desc' }],
        limit: limit,
        skip: skip
      });
      return result.docs;
    } catch (error) {
      console.error('Error finding point transactions by type:', error);
      throw error;
    }
  }

  static async findById(id) {
    try {
      const transaction = await couchdbService.get(id);
      if (transaction.type !== 'point_transaction') {
        return null;
      }
      return transaction;
    } catch (error) {
      if (error.statusCode === 404) {
        return null;
      }
      console.error('Error finding point transaction by ID:', error);
      throw error;
    }
  }

  static async getUserBalance(userId) {
    try {
      // Get the most recent transaction for the user to find current balance
      const result = await couchdbService.find({
        selector: {
          type: 'point_transaction',
          user: userId
        },
        sort: [{ createdAt: 'desc' }],
        limit: 1
      });

      if (result.docs.length === 0) {
        return 0;
      }

      return result.docs[0].balanceAfter;
    } catch (error) {
      console.error('Error getting user balance:', error);
      throw error;
    }
  }

  static async getUserTransactionHistory(userId, startDate, endDate) {
    try {
      const selector = {
        type: 'point_transaction',
        user: userId
      };

      if (startDate || endDate) {
        selector.createdAt = {};
        if (startDate) {
          selector.createdAt.$gte = startDate;
        }
        if (endDate) {
          selector.createdAt.$lte = endDate;
        }
      }

      const result = await couchdbService.find({
        selector: selector,
        sort: [{ createdAt: 'desc' }]
      });

      return result.docs;
    } catch (error) {
      console.error('Error getting user transaction history:', error);
      throw error;
    }
  }

  static async getTransactionStats(userId, startDate, endDate) {
    try {
      const transactions = await this.getUserTransactionHistory(userId, startDate, endDate);
      
      const stats = {
        totalEarned: 0,
        totalSpent: 0,
        transactionCount: transactions.length,
        transactionBreakdown: {}
      };

      transactions.forEach(transaction => {
        if (transaction.amount > 0) {
          stats.totalEarned += transaction.amount;
        } else {
          stats.totalSpent += Math.abs(transaction.amount);
        }

        const type = transaction.transactionType;
        if (!stats.transactionBreakdown[type]) {
          stats.transactionBreakdown[type] = { count: 0, total: 0 };
        }
        stats.transactionBreakdown[type].count++;
        stats.transactionBreakdown[type].total += transaction.amount;
      });

      return stats;
    } catch (error) {
      console.error('Error getting transaction stats:', error);
      throw error;
    }
  }
}

module.exports = PointTransaction;