from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from rest_framework.permissions import IsAuthenticated
from django.db import transaction
from questbanker_api.utils import get_current_user
from .soft_delete_helper import soft_delete_transaction_by_reference, _determine_transaction_types
from .soft_delete_serializers import TransactionSoftDeleteSerializer, TransactionInfoSerializer
from ledgers.models import SystemTransactions
from organisations.models import OrganisationBranch
import logging

logger = logging.getLogger(__name__)

class TransactionSoftDeleteView(APIView):
    
    permission_classes = [IsAuthenticated]
    
    def post(self, request, format=None):
        """
        Soft delete a transaction by reference number.
        
        Expected payload:
        {
            "reference_number": "ln-d-2512-00001",
            "branch_id": 1,
            "reason": "Optional reason for deletion"
        }
        """
        
        try:
            # Validate request data
            serializer = TransactionSoftDeleteSerializer(data=request.data)
            if not serializer.is_valid():
                return Response({
                    'success': False,
                    'message': 'Invalid request data',
                    'errors': serializer.errors
                }, status=status.HTTP_400_BAD_REQUEST)
            
            # Get validated data
            reference_number = serializer.validated_data['reference_number']
            branch_id = serializer.validated_data.get('branch_id')
            reason = serializer.validated_data.get('reason', 'Soft delete requested by user')
            
            # Use branch_id from request or fall back to current user's branch
            if not branch_id:
                branch_id = get_current_user(request, 'organisation_branch_id', None)
                if not branch_id:
                    return Response({
                        'success': False,
                        'message': 'Branch ID is required'
                    }, status=status.HTTP_400_BAD_REQUEST)
            
            # Validate branch exists
            try:
                branch = OrganisationBranch.objects.get(pk=branch_id)
            except OrganisationBranch.DoesNotExist:
                return Response({
                    'success': False,
                    'message': 'Invalid branch'
                }, status=status.HTTP_400_BAD_REQUEST)
            
            # Perform soft delete
            result = soft_delete_transaction_by_reference(reference_number, branch_id, user_id=request.user.id, branch=branch)
            
            if result['success']:
                # Log the deletion
                logger.info(f'Transaction {reference_number} soft deleted by user {request.user.username}. Reason: {reason}')
                
                return Response({
                    'success': True,
                    'message': result['message'],
                    'reference_number': reference_number,
                    'deleted_by': request.user.username,
                    'reason': reason
                }, status=status.HTTP_200_OK)
            else:
                return Response({
                    'success': False,
                    'message': result['message']
                }, status=status.HTTP_400_BAD_REQUEST)
                
        except Exception as e:
            logger.error(f'Error in TransactionSoftDeleteView: {str(e)}')
            return Response({
                'success': False,
                'message': f'An error occurred while processing the request: {str(e)}'
            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
    
    def get(self, request, format=None):
        """
        Get information about a transaction before deletion.
        
        Query parameters:
        - reference_number: The reference number to check
        """
        
        try:
            reference_number = request.query_params.get('reference_number')
            
            if not reference_number:
                return Response({
                    'success': False,
                    'message': 'Reference number is required'
                }, status=status.HTTP_400_BAD_REQUEST)
            
            # Get current user's branch
            branch_id = get_current_user(request, 'organisation_branch_id', None)
            if not branch_id:
                return Response({
                    'success': False,
                    'message': 'User branch information not found'
                }, status=status.HTTP_400_BAD_REQUEST)
            
            # Find the transaction
            system_transaction = SystemTransactions.objects.filter(
                reference_no=reference_number,
                branch_id=branch_id,
                deleted=False
            ).first()
            
            if not system_transaction:
                return Response({
                    'success': False,
                    'message': f'Transaction with reference number {reference_number} not found or already deleted'
                }, status=status.HTTP_404_NOT_FOUND)
            
            # Get transaction details
            transaction_info = {
                'reference_number': system_transaction.reference_no,
                'amount': system_transaction.amount,
                'heading': system_transaction.heading,
                'payment_method': system_transaction.payment_method,
                'record_date': system_transaction.record_date,
                'added_by': system_transaction.added_by.username if system_transaction.added_by else None,
                'credit_account': system_transaction.credit_chart.account_name if system_transaction.credit_chart else None,
                'debit_account': system_transaction.debit_chart.account_name if system_transaction.debit_chart else None,
                'branch': system_transaction.branch.name if system_transaction.branch else None,
                'can_delete': True,  # Add any business logic here to determine if deletion is allowed
                'transaction_type': ', '.join(_determine_transaction_types(reference_number))
            }
            
            return Response({
                'success': True,
                'transaction': transaction_info
            }, status=status.HTTP_200_OK)
            
        except Exception as e:
            logger.error(f'Error getting transaction info: {str(e)}')
            return Response({
                'success': False,
                'message': f'An error occurred while retrieving transaction information: {str(e)}'
            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)