/**
 * 模型索引文件
 * @file index.js
 * @description 导出所有模型并建立关联关系
 */
const { sequelize } = require('../config/database');

// 导入所有模型
const User = require('./User');
const Role = require('./Role');
const Account = require('./Account');
const Transaction = require('./Transaction');
const LoanProduct = require('./LoanProduct');
const Employee = require('./Employee')(sequelize);
const Department = require('./Department');
const Position = require('./Position');
const Report = require('./Report');
const Project = require('./Project');
const SupervisionTask = require('./SupervisionTask');
const InstallationTask = require('./InstallationTask');
const CompletedSupervision = require('./CompletedSupervision');
const LoanApplication = require('./LoanApplication');
const AuditRecord = require('./AuditRecord');
const LoanContract = require('./LoanContract');
const LoanRelease = require('./LoanRelease');
const LoanReleaseHistory = require('./LoanReleaseHistory');

// 定义模型关联关系

// 用户与角色关联
User.belongsTo(Role, {
  foreignKey: 'role_id',
  as: 'role',
  targetKey: 'id'
});

Role.hasMany(User, {
  foreignKey: 'role_id',
  as: 'users'
});

// 用户与账户关联
User.hasMany(Account, {
  foreignKey: 'user_id',
  as: 'accounts'
});

Account.belongsTo(User, {
  foreignKey: 'user_id',
  as: 'user'
});

// 账户与交易记录关联
Account.hasMany(Transaction, {
  foreignKey: 'account_id',
  as: 'transactions'
});

Transaction.belongsTo(Account, {
  foreignKey: 'account_id',
  as: 'account'
});

// 交易记录与用户关联（通过账户）
// 移除不合理的Transaction->User through Account的belongsTo定义，避免错误外键映射

// 员工关联关系（Employee模型使用字符串字段存储部门和职位，不需要关联）

// 报表与用户关联
Report.belongsTo(User, {
  foreignKey: 'createdBy',
  as: 'creator',
  targetKey: 'id'
});

User.hasMany(Report, {
  foreignKey: 'createdBy',
  as: 'reports'
});

// 项目与用户关联（创建人）
Project.belongsTo(User, {
  foreignKey: { name: 'createdBy', field: 'createdBy' },
  as: 'creator',
  targetKey: 'id'
});

User.hasMany(Project, {
  foreignKey: 'createdBy',
  as: 'createdProjects'
});

// 项目与用户关联（更新人）
Project.belongsTo(User, {
  foreignKey: { name: 'updatedBy', field: 'updatedBy' },
  as: 'updater',
  targetKey: 'id'
});

User.hasMany(Project, {
  foreignKey: 'updatedBy',
  as: 'updatedProjects'
});

// 监管任务与用户关联（创建人）
SupervisionTask.belongsTo(User, {
  foreignKey: 'createdBy',
  as: 'creator',
  targetKey: 'id'
});

User.hasMany(SupervisionTask, {
  foreignKey: 'createdBy',
  as: 'createdSupervisionTasks'
});

// 监管任务与用户关联（更新人）
SupervisionTask.belongsTo(User, {
  foreignKey: 'updatedBy',
  as: 'updater',
  targetKey: 'id'
});

User.hasMany(SupervisionTask, {
  foreignKey: 'updatedBy',
  as: 'updatedSupervisionTasks'
});

// 待安装任务与用户关联（创建人）
InstallationTask.belongsTo(User, {
  foreignKey: 'createdBy',
  as: 'creator',
  targetKey: 'id'
});

User.hasMany(InstallationTask, {
  foreignKey: 'createdBy',
  as: 'createdInstallationTasks'
});

// 待安装任务与用户关联（更新人）
InstallationTask.belongsTo(User, {
  foreignKey: 'updatedBy',
  as: 'updater',
  targetKey: 'id'
});

User.hasMany(InstallationTask, {
  foreignKey: 'updatedBy',
  as: 'updatedInstallationTasks'
});

// 监管任务已结项与用户关联（创建人）
CompletedSupervision.belongsTo(User, {
  foreignKey: 'createdBy',
  as: 'creator',
  targetKey: 'id'
});

User.hasMany(CompletedSupervision, {
  foreignKey: 'createdBy',
  as: 'createdCompletedSupervisions'
});

// 监管任务已结项与用户关联（更新人）
CompletedSupervision.belongsTo(User, {
  foreignKey: 'updatedBy',
  as: 'updater',
  targetKey: 'id'
});

User.hasMany(CompletedSupervision, {
  foreignKey: 'updatedBy',
  as: 'updatedCompletedSupervisions'
});

// 贷款商品与用户关联（创建人）
LoanProduct.belongsTo(User, {
  foreignKey: 'createdBy',
  as: 'creator',
  targetKey: 'id'
});

User.hasMany(LoanProduct, {
  foreignKey: 'createdBy',
  as: 'createdLoanProducts'
});

// 贷款商品与用户关联（更新人）
LoanProduct.belongsTo(User, {
  foreignKey: 'updatedBy',
  as: 'updater',
  targetKey: 'id'
});

User.hasMany(LoanProduct, {
  foreignKey: 'updatedBy',
  as: 'updatedLoanProducts'
});

// 贷款申请暂时不关联用户表，因为当前表结构中没有外键字段
// 如果需要关联，需要先添加相应的外键字段到数据库表中

// 审核记录与贷款申请关联
AuditRecord.belongsTo(LoanApplication, {
  foreignKey: 'applicationId',
  as: 'application',
  targetKey: 'id'
});

LoanApplication.hasMany(AuditRecord, {
  foreignKey: 'applicationId',
  as: 'auditRecords'
});

// 审核记录与用户关联（审核人）
AuditRecord.belongsTo(User, {
  foreignKey: 'auditorId',
  as: 'auditorUser',
  targetKey: 'id'
});

User.hasMany(AuditRecord, {
  foreignKey: 'auditorId',
  as: 'auditRecords'
});

// 贷款合同暂时不关联用户表，因为当前表结构中没有外键字段
// 如果需要关联，需要先添加相应的外键字段到数据库表中

// 贷款解押与用户关联（处理人）
LoanRelease.belongsTo(User, {
  foreignKey: 'processor_id',
  as: 'processor',
  targetKey: 'id'
});

User.hasMany(LoanRelease, {
  foreignKey: 'processor_id',
  as: 'processedReleases'
});

// 贷款解押与贷款合同关联
LoanRelease.belongsTo(LoanContract, {
  foreignKey: 'contract_id',
  as: 'contract',
  targetKey: 'id'
});

LoanContract.hasMany(LoanRelease, {
  foreignKey: 'contract_id',
  as: 'releases'
});

// 贷款解押历史记录与解押申请关联
LoanReleaseHistory.belongsTo(LoanRelease, {
  foreignKey: 'release_id',
  as: 'release',
  targetKey: 'id'
});

LoanRelease.hasMany(LoanReleaseHistory, {
  foreignKey: 'release_id',
  as: 'histories'
});

// 贷款解押历史记录与用户关联（操作人）
LoanReleaseHistory.belongsTo(User, {
  foreignKey: 'operator_id',
  as: 'operatorUser',
  targetKey: 'id'
});

User.hasMany(LoanReleaseHistory, {
  foreignKey: 'operator_id',
  as: 'releaseHistories'
});

// 导出所有模型和数据库实例
module.exports = {
  sequelize,
  User,
  Role,
  Account,
  Transaction,
  LoanProduct,
  Employee,
  Department,
  Position,
  Report,
  Project,
  SupervisionTask,
  InstallationTask,
  CompletedSupervision,
  LoanApplication,
  AuditRecord,
  LoanContract,
  LoanRelease,
  LoanReleaseHistory
};