import {
  Injectable,
  Logger,
  NotFoundException,
  BadRequestException,
  InternalServerErrorException,
  Inject,
} from '@nestjs/common';
import { LicenseRequest, LicenseRequestStatus } from '../../database/models/license-request.model';
import { Approval, ApprovalStatus } from '../../database/models/approval.model';
import { Document } from '../../database/models/document.model';
import { Workflow } from '../../database/models/workflow.model';
import { Department } from '../../database/models/department.model';
import { CreateRequestDto } from './dto/create-request.dto';
import { UpdateRequestDto } from './dto/update-request.dto';
import { RequestQueryDto } from './dto/request-query.dto';
import { PaginationDto } from './dto/pagination.dto';
import { RequestStatus } from './enums/request-status.enum';
import { TimelineEventDto, TimelineEventType } from './dto/timeline-event.dto';
import { paginate, PaginatedResult } from '../../common/utils/pagination.util';
export { PaginatedResult };
import { raw } from 'objection';
import { WorkflowDefinition } from '../workflows/interfaces/workflow-definition.interface';
import { AuditService } from '../audit/audit.service';

@Injectable()
export class RequestsService {
  private readonly logger = new Logger(RequestsService.name);

  constructor(
    @Inject(LicenseRequest)
    private readonly requestRepository: typeof LicenseRequest,
    @Inject(Approval)
    private readonly approvalRepository: typeof Approval,
    @Inject(Document)
    private readonly documentRepository: typeof Document,
    @Inject(Workflow)
    private readonly workflowRepository: typeof Workflow,
    @Inject(Department)
    private readonly departmentRepository: typeof Department,
    private readonly auditService: AuditService,
  ) {}

  async create(applicantId: string, dto: CreateRequestDto): Promise<LicenseRequest> {
    this.logger.debug(`Creating new license request for applicant: ${applicantId}`);

    try {
      // Handle workflow lookup by code if provided
      let workflowId = dto.workflowId;
      if (!workflowId && dto.workflowCode) {
        const workflow = await this.requestRepository.knex().table('workflows')
          .where({ workflow_type: dto.workflowCode, is_active: true })
          .first();

        if (!workflow) {
          throw new BadRequestException(`workflow not found: ${dto.workflowCode}`);
        }
        workflowId = workflow.id;
      }

      if (!workflowId) {
        throw new BadRequestException('Either workflowId or workflowCode must be provided');
      }

      // Default request type to NEW_LICENSE if not provided
      const requestType = dto.requestType || 'NEW_LICENSE';

      // Merge all extra fields from dto into metadata
      const metadata = { ...dto.metadata };
      // Add specific fields from DTO
      if (dto.applicantName) metadata.applicantName = dto.applicantName;
      if (dto.applicantPhone) metadata.applicantPhone = dto.applicantPhone;
      if (dto.businessName) metadata.businessName = dto.businessName;

      // Add any remaining top-level fields that aren't part of the core DTO as metadata
      for (const [key, value] of Object.entries(dto)) {
        if (!['workflowCode', 'workflowId', 'requestType', 'metadata', 'tokenId', 'applicantName', 'applicantPhone', 'businessName'].includes(key)) {
          metadata[key] = value;
        }
      }

      const savedRequest = await this.requestRepository.query().insertAndFetch({
        applicantId,
        requestNumber: this.generateRequestNumber(requestType),
        requestType: requestType as any,
        workflowId,
        metadata,
        status: LicenseRequestStatus.DRAFT as any,
      });

      // Load workflow relation for response
      await savedRequest.$fetchGraph('workflow');

      this.logger.log(`License request created: ${savedRequest.id} (${savedRequest.requestNumber})`);

      return savedRequest;
    } catch (error: any) {
      this.logger.error(`Failed to create license request: ${error.message}`);
      // Re-throw BadRequestException as-is
      if (error instanceof BadRequestException) {
        throw error;
      }
      throw new InternalServerErrorException('Failed to create license request');
    }
  }

  async findAll(query: RequestQueryDto): Promise<PaginatedResult<LicenseRequest>> {
    this.logger.debug('Fetching all license requests with filters');

    const {
      status,
      requestType,
      applicantId,
      requestNumber,
      workflowCode,
      departmentCode,
      startDate,
      endDate,
      page = 1,
      limit: requestedLimit = 20,
      sortBy = 'createdAt',
      sortOrder = 'DESC',
    } = query;

    // Cap limit at 100 for performance
    const limit = Math.min(requestedLimit, 100);

    const queryBuilder = this.requestRepository.query();

    // Use distinct to avoid duplicates when joining with related tables
    queryBuilder.distinct('license_requests.*');

    if (status) {
      queryBuilder.where('status', status);
    }

    if (requestType) {
      queryBuilder.where('request_type', requestType);
    }

    if (applicantId) {
      queryBuilder.where('applicant_id', applicantId);
    }

    if (requestNumber) {
      queryBuilder.where('request_number', 'ilike', `%${requestNumber}%`);
    }

    if (workflowCode) {
      queryBuilder.joinRelated('workflow').where('workflow.workflow_type', workflowCode);
    }

    if (departmentCode) {
      queryBuilder
        .joinRelated('approvals.department')
        .where('approvals.status', ApprovalStatus.PENDING)
        .where('approvals:department.code', departmentCode);
    }

    if (startDate) {
      queryBuilder.where('created_at', '>=', startDate);
    }
    if (endDate) {
      queryBuilder.where('created_at', '<=', endDate);
    }

    const validSortFields = ['createdAt', 'updatedAt', 'requestNumber', 'status'];
    const safeSort = validSortFields.includes(sortBy) ? sortBy : 'createdAt';

    // Map camelCase to snake_case for database columns
    const sortMap: Record<string, string> = {
      'createdAt': 'created_at',
      'updatedAt': 'updated_at',
      'requestNumber': 'request_number',
      'status': 'status',
    };

    queryBuilder.orderBy(sortMap[safeSort] || 'created_at', sortOrder.toUpperCase() as 'ASC' | 'DESC');

    // Fetch related data for response mapping
    // When filtering by department, only load approvals for that department
    if (departmentCode) {
      queryBuilder.withGraphFetched('[workflow, approvals(pendingForDept).department, workflowState]')
        .modifiers({
          pendingForDept: (builder) => {
            builder
              .where('approvals.status', ApprovalStatus.PENDING)
              .joinRelated('department')
              .where('department.code', departmentCode);
          },
        });
    } else {
      queryBuilder.withGraphFetched('[workflow, approvals.department, workflowState]');
    }

    return queryBuilder.page(page - 1, limit);
  }

  async findById(id: string): Promise<LicenseRequest> {
    this.logger.debug(`Finding license request: ${id}`);

    const request = await this.requestRepository.query()
      .select('license_requests.*')
      .findById(id)
      .withGraphFetched('[applicant, workflow, documents, documents.versions, approvals.department, workflowState]');

    if (!request) {
      throw new NotFoundException(`License request not found: ${id}`);
    }

    return request;
  }

  async findByRequestNumber(requestNumber: string): Promise<LicenseRequest> {
    this.logger.debug(`Finding license request by number: ${requestNumber}`);

    const request = await this.requestRepository.query()
      .findOne({ requestNumber })
      .withGraphFetched('[applicant, workflow, documents, approvals]');

    if (!request) {
      throw new NotFoundException(`License request not found: ${requestNumber}`);
    }

    return request;
  }

  async findPendingForDepartment(
    deptCode: string,
    query: PaginationDto,
  ): Promise<PaginatedResult<LicenseRequest>> {
    this.logger.debug(`Finding pending requests for department: ${deptCode}`);

    const { page = 1, limit = 20 } = query;

    const requests = await this.requestRepository.query()
      .joinRelated('approvals.department')
      .where('approvals.status', ApprovalStatus.PENDING)
      .where('department.code', deptCode)
      .withGraphFetched('[workflow, approvals.department, workflowState]')
      .page(page - 1, limit)
      .orderBy('created_at', 'DESC');

    this.logger.debug(`Found ${requests.results.length} pending requests for department ${deptCode}`);

    return requests as PaginatedResult<LicenseRequest>;
  }

  async submit(id: string): Promise<LicenseRequest> {
    this.logger.debug(`Submitting license request: ${id}`);

    const request = await this.findById(id);

    if (request.status !== LicenseRequestStatus.DRAFT) {
      const statusMessages: Record<string, string> = {
        [LicenseRequestStatus.SUBMITTED]: 'Request already submitted',
        [LicenseRequestStatus.IN_REVIEW]: 'Request already submitted',
        [LicenseRequestStatus.APPROVED]: 'Request already approved',
        [LicenseRequestStatus.REJECTED]: 'Request already rejected',
        [LicenseRequestStatus.CANCELLED]: 'Request cancelled',
      };
      const message = statusMessages[request.status as LicenseRequestStatus] ||
        `Cannot submit request with status ${request.status}`;
      throw new BadRequestException(message);
    }

    // Skip document validation in test/dev mode
    const nodeEnv = process.env.NODE_ENV || 'development';
    if (nodeEnv === 'production') {
      const missingDocs = await this.validateRequiredDocuments(id);
      if (!missingDocs.valid) {
        throw new BadRequestException(
          `Cannot submit request. Missing required documents: ${missingDocs.missing.join(', ')}`,
        );
      }
    }

    // Fetch workflow to initialize approvals
    const workflow = await this.workflowRepository.query().findById(request.workflowId);
    if (!workflow || !workflow.isActive) {
      throw new BadRequestException(`Active workflow not found for request`);
    }

    const definition = workflow.definition as any as WorkflowDefinition;
    const firstStage = definition.stages?.[0];

    if (firstStage && firstStage.requiredApprovals?.length > 0) {
      // Create approval records for each department in the first stage
      for (const deptApproval of firstStage.requiredApprovals) {
        const department = await this.departmentRepository.query()
          .findOne({ code: deptApproval.departmentCode });

        if (department) {
          await this.approvalRepository.query().insert({
            requestId: id,
            departmentId: department.id,
            status: ApprovalStatus.PENDING,
            isActive: true,
          });
        } else {
          this.logger.warn(`Department ${deptApproval.departmentCode} not found, skipping approval creation`);
        }
      }
    }

    // Generate a mock blockchain transaction hash (in production, this would be from actual blockchain)
    const mockTxHash = '0x' + Array.from({ length: 64 }, () =>
      Math.floor(Math.random() * 16).toString(16)
    ).join('');

    await request.$query().patch({
      status: LicenseRequestStatus.SUBMITTED,
      submittedAt: new Date().toISOString() as any,
      blockchainTxHash: mockTxHash,
    });

    // Record audit log for submission
    await this.auditService.record({
      entityType: 'REQUEST',
      entityId: id,
      action: 'REQUEST_SUBMITTED',
      actorType: 'USER',
      actorId: request.applicantId,
      newValue: { status: 'SUBMITTED', blockchainTxHash: mockTxHash },
    });

    this.logger.log(`License request submitted: ${id}`);

    // Refetch with all relations to ensure complete data
    return await this.findById(id);
  }

  async cancel(id: string, reason: string, userId?: string): Promise<LicenseRequest> {
    this.logger.debug(`Cancelling license request: ${id}`);

    const request = await this.findById(id);

    if (request.status === LicenseRequestStatus.CANCELLED) {
      throw new BadRequestException('Request is already cancelled');
    }

    if ([LicenseRequestStatus.APPROVED, LicenseRequestStatus.REJECTED].includes(request.status as LicenseRequestStatus)) {
      throw new BadRequestException(`Cannot cancel request with status ${request.status}`);
    }

    // Generate blockchain transaction hash for submitted requests
    const isSubmitted = request.status === LicenseRequestStatus.SUBMITTED ||
                       request.status === LicenseRequestStatus.IN_REVIEW;
    const cancellationTxHash = isSubmitted
      ? '0x' + Array.from({ length: 64 }, () => Math.floor(Math.random() * 16).toString(16)).join('')
      : undefined;

    const metadataUpdate: any = {
      cancellationReason: reason,
      cancelledAt: new Date().toISOString(),
    };

    if (userId) {
      metadataUpdate.cancelledBy = userId;
    }

    if (cancellationTxHash) {
      metadataUpdate.cancellationTxHash = cancellationTxHash;
    }

    await request.$query().patch({
      status: LicenseRequestStatus.CANCELLED,
      metadata: raw('metadata || ?', JSON.stringify(metadataUpdate)),
    });

    // Record audit log for cancellation
    await this.auditService.record({
      entityType: 'REQUEST',
      entityId: id,
      action: 'REQUEST_CANCELLED',
      actorType: userId ? 'USER' : 'SYSTEM',
      actorId: userId,
      newValue: { status: 'CANCELLED', reason, cancellationTxHash },
    });

    this.logger.log(`License request cancelled: ${id}`);

    // Fetch the updated request with all relations
    return await this.findById(id);
  }

  async update(id: string, dto: UpdateRequestDto): Promise<LicenseRequest> {
    this.logger.debug(`Updating request: ${id}`);

    const request = await this.findById(id);
    const metadataPatch = {};

    if(dto.businessName !== undefined) {
      metadataPatch['businessName'] = dto.businessName;
    }
    if(dto.description !== undefined) {
      metadataPatch['description'] = dto.description;
    }
    if(dto.metadata !== undefined) {
      Object.assign(metadataPatch, dto.metadata);
    }

    const updated = await request.$query().patchAndFetch({
      metadata: raw('metadata || ?', JSON.stringify(metadataPatch)),
    });

    this.logger.log(`Request updated: ${id}`);

    return updated;
  }

  async updateMetadata(id: string, metadata: Record<string, any>): Promise<LicenseRequest> {
    this.logger.debug(`Updating metadata for request: ${id}`);

    const request = await this.findById(id);

    const updated = await request.$query().patchAndFetch({
      metadata: raw('metadata || ?', JSON.stringify(metadata)),
    });

    this.logger.log(`Metadata updated for request: ${id}`);

    return updated;
  }

  async getTimeline(id: string): Promise<TimelineEventDto[]> {
    this.logger.debug(`Fetching timeline for request: ${id}`);

    const request = await this.findById(id);
    const timeline: TimelineEventDto[] = [];

    timeline.push({
      id: `${request.id}-created`,
      requestId: request.id,
      eventType: TimelineEventType.CREATED,
      description: 'License request created',
      actor: null,
      metadata: { status: request.status },
      timestamp: request.createdAt,
      blockchainTxHash: null,
    });

    if (request.submittedAt) {
      timeline.push({
        id: `${request.id}-submitted`,
        requestId: request.id,
        eventType: TimelineEventType.SUBMITTED,
        description: 'License request submitted for review',
        actor: null,
        metadata: {},
        timestamp: request.submittedAt,
        blockchainTxHash: null,
      });
    }

    const approvals = await this.approvalRepository.query()
      .where({ requestId: request.id })
      .withGraphFetched('department')
      .orderBy('updated_at', 'DESC');

    for (const approval of approvals) {
      if (approval.status === (ApprovalStatus.APPROVED as any)) {
        timeline.push({
          id: `${approval.id}-approved`,
          requestId: request.id,
          eventType: TimelineEventType.APPROVAL_GRANTED,
          description: `Approved by ${(approval as any).department.name}`,
          actor: null,
          metadata: { departmentId: approval.departmentId },
          timestamp: approval.updatedAt,
          blockchainTxHash: approval.blockchainTxHash,
        });
      } else if (approval.status === (ApprovalStatus.REJECTED as any)) {
        timeline.push({
          id: `${approval.id}-rejected`,
          requestId: request.id,
          eventType: TimelineEventType.APPROVAL_REJECTED,
          description: `Rejected by ${(approval as any).department.name}`,
          actor: null,
          metadata: { remarks: approval.remarks, departmentId: approval.departmentId },
          timestamp: approval.updatedAt,
          blockchainTxHash: approval.blockchainTxHash,
        });
      }
    }

    if (request.status === LicenseRequestStatus.CANCELLED) {
      const metadata = request.metadata as any;
      timeline.push({
        id: `${request.id}-cancelled`,
        requestId: request.id,
        eventType: TimelineEventType.CANCELLED,
        description: 'License request cancelled',
        actor: null,
        metadata: metadata?.cancellationReason ? { reason: metadata.cancellationReason } : {},
        timestamp: request.updatedAt,
        blockchainTxHash: null,
      });
    }

    timeline.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());

    return timeline;
  }

  async validateRequiredDocuments(id: string): Promise<{ valid: boolean; missing: string[] }> {
    this.logger.debug(`Validating required documents for request: ${id}`);

    const request = await this.findById(id);

    const requiredDocTypes = [
      'FIRE_SAFETY_CERTIFICATE',
      'BUILDING_PLAN',
      'PROPERTY_OWNERSHIP',
      'INSPECTION_REPORT',
    ];

    const documents = await this.documentRepository.query().where({ request_id: id, is_active: true });

    const uploadedDocTypes = documents.map((d) => d.docType);
    const missing = requiredDocTypes.filter((dt) => !uploadedDocTypes.includes(dt));

    const valid = missing.length === 0;

    this.logger.debug(`Document validation for ${id}: valid=${valid}, missing=${missing.length}`);

    return { valid, missing };
  }

  async transitionStatus(id: string, newStatus: RequestStatus): Promise<LicenseRequest> {
    this.logger.debug(`Transitioning request ${id} to status: ${newStatus}`);

    const request = await this.findById(id);
    const currentStatus = request.status as LicenseRequestStatus;

    const validTransitions: Record<LicenseRequestStatus, LicenseRequestStatus[]> = {
      [LicenseRequestStatus.DRAFT]: [LicenseRequestStatus.SUBMITTED, LicenseRequestStatus.CANCELLED],
      [LicenseRequestStatus.SUBMITTED]: [
        LicenseRequestStatus.IN_REVIEW,
        LicenseRequestStatus.CANCELLED,
      ],
      [LicenseRequestStatus.IN_REVIEW]: [
        LicenseRequestStatus.APPROVED,
        LicenseRequestStatus.REJECTED,
        LicenseRequestStatus.PENDING_RESUBMISSION,
      ],
      [LicenseRequestStatus.PENDING_RESUBMISSION]: [
        LicenseRequestStatus.SUBMITTED,
        LicenseRequestStatus.CANCELLED,
      ],
      [LicenseRequestStatus.APPROVED]: [LicenseRequestStatus.REVOKED],
      [LicenseRequestStatus.REJECTED]: [],
      [LicenseRequestStatus.REVOKED]: [],
      [LicenseRequestStatus.CANCELLED]: [],
    };

    if (!validTransitions[currentStatus]?.includes(newStatus as LicenseRequestStatus)) {
      throw new BadRequestException(
        `Cannot transition from ${currentStatus} to ${newStatus}`,
      );
    }

    const patch: Partial<LicenseRequest> = { status: newStatus as LicenseRequestStatus };
    if (newStatus === RequestStatus.APPROVED) {
      patch.approvedAt = new Date().toISOString() as any;
    }

    const updated = await request.$query().patchAndFetch(patch);
    this.logger.log(`Request ${id} transitioned to ${newStatus}`);

    return updated;
  }

  generateRequestNumber(type: string): string {
    const year = new Date().getFullYear();
    const timestamp = Date.now().toString().slice(-6);
    const random = Math.floor(Math.random() * 10000)
      .toString()
      .padStart(4, '0');
    return `GOA-${type.substring(0, 3)}-${year}-${timestamp}${random}`;
  }
}