Document Flow Logic

class DocumentService {

  /** Create a new document with metadata and initial file upload */
  async createDocument(projectId, metadata, file) {
    const docNumber = await this.generateDocNumber(projectId, metadata.discipline);
    const fileUrl = await StorageService.upload(file, 'documents');
    const doc = await DocumentMaster.create({
      project_id: projectId, doc_number: docNumber,
      doc_title: metadata.title, doc_type: metadata.type,
      discipline: metadata.discipline, current_revision: '00',
      status: 'draft'
    });
    await DocumentRevision.create({
      doc_id: doc.doc_id, revision_code: '00',
      file_url: fileUrl, review_status: 'pending'
    });
    return doc;
  }

  /** Submit document for internal review by assigned reviewers */
  async submitForReview(docId, reviewerIds) {
    const doc = await DocumentMaster.findById(docId);
    await doc.update({ status: 'under_review' });
    const reviews = reviewerIds.map(rid => ({
      doc_id: docId, reviewer_id: rid,
      review_status: 'pending', review_code: null, comments: null
    }));
    await DocumentReview.bulkCreate(reviews);
    await NotificationService.notify(reviewerIds, 'Document review assigned', doc);
    return reviews;
  }

  /** Process a reviewer's response with review code (A/B/C/D) */
  async processReviewResponse(reviewId, code, comments) {
    await DocumentReview.update(reviewId, {
      review_code: code, comments, review_status: 'completed'
    });
    const review = await DocumentReview.findById(reviewId);
    const allReviews = await DocumentReview.findAll({ doc_id: review.doc_id });
    const allCompleted = allReviews.every(r => r.review_status === 'completed');
    if (allCompleted) {
      const hasReject = allReviews.some(r => ['C', 'D'].includes(r.review_code));
      if (hasReject) {
        await DocumentMaster.update(review.doc_id, { status: 'revision_required' });
        await TaskService.createRevisionTask(review.doc_id);
      } else {
        await DocumentMaster.update(review.doc_id, { status: 'approved' });
      }
    }
  }

  /** Create a new revision of an existing document */
  async createRevision(docId, file, description) {
    const doc = await DocumentMaster.findById(docId);
    const newCode = this.nextRevisionCode(doc.current_revision);
    const fileUrl = await StorageService.upload(file, 'documents');
    // Supersede previous revision
    await DocumentRevision.update(
      { doc_id: docId, revision_code: doc.current_revision },
      { review_status: 'superseded' }
    );
    const revision = await DocumentRevision.create({
      doc_id: docId, revision_code: newCode,
      file_url: fileUrl, review_status: 'pending'
    });
    await doc.update({ current_revision: newCode, status: 'draft' });
    return revision;
  }

  /** Create a transmittal package for external distribution */
  async createTransmittal(projectId, docIds, toOrg) {
    if (!docIds || docIds.length === 0) {
      throw new ValidationError('Transmittal must include at least one document');
    }
    const transNumber = await this.generateTransmittalNumber(projectId);
    const transmittal = await Transmittal.create({
      project_id: projectId, transmittal_number: transNumber,
      from_org: await ProjectService.getOrg(projectId),
      to_org: toOrg, purpose: 'For Review', status: 'issued'
    });
    for (const docId of docIds) {
      const doc = await DocumentMaster.findById(docId);
      await TransmittalItem.create({
        transmittal_id: transmittal.transmittal_id,
        doc_id: docId, revision_code: doc.current_revision
      });
    }
    await NotificationService.notifyOrg(toOrg, 'Transmittal received', transmittal);
    return transmittal;
  }

  /** Raise a Request for Information */
  async createRFI(projectId, subject, assignedTo) {
    const rfiNumber = await this.generateRFINumber(projectId);
    const rfi = await RFI.create({
      project_id: projectId, rfi_number: rfiNumber,
      subject, raised_by: AuthService.currentUserId(),
      assigned_to: assignedTo, status: 'raised',
      due_date: DateUtil.addBusinessDays(new Date(), 7)
    });
    await NotificationService.notify([assignedTo], 'New RFI assigned', rfi);
    return rfi;
  }

  /** Create a submittal package for material/method approval */
  async createSubmittal(projectId, type, docIds) {
    const submittalNumber = await this.generateSubmittalNumber(projectId);
    const submittal = await Submittal.create({
      project_id: projectId, submittal_number: submittalNumber,
      submittal_type: type, review_status: 'pending'
    });
    for (const docId of docIds) {
      await SubmittalItem.create({ submittal_id: submittal.submittal_id, doc_id: docId });
    }
    return submittal;
  }

  /** Distribute an approved document to specified recipients */
  async distributeDocument(docId, recipientIds) {
    const doc = await DocumentMaster.findById(docId);
    if (doc.status !== 'approved') {
      throw new ValidationError('Only approved documents can be distributed');
    }
    for (const recipientId of recipientIds) {
      await DocumentDistribution.create({
        doc_id: docId, revision_code: doc.current_revision,
        recipient_id: recipientId, distributed_at: new Date()
      });
    }
    await NotificationService.notify(recipientIds, 'Document distributed', doc);
    return { doc_id: docId, distributed_to: recipientIds.length };
  }
}