/**
 * 模型索引文件
 * @file index.js
 * @description 导出所有模型并建立关联关系
 */
const { sequelize } = require('../config/database-simple');
const BaseModel = require('./BaseModel');
const Farm = require('./Farm');
const Animal = require('./Animal');
const Device = require('./Device');
const Alert = require('./Alert');
const User = require('./User');
const Role = require('./Role');
const UserRole = require('./UserRole');
const Product = require('./Product');
const Order = require('./Order');
const OrderItem = require('./OrderItem');
const SensorData = require('./SensorData');

// 建立模型之间的关联关系

// 养殖场与动物的一对多关系
Farm.hasMany(Animal, { 
  foreignKey: 'farm_id',
  as: 'animals',
  onDelete: 'CASCADE',
  onUpdate: 'CASCADE'
});
Animal.belongsTo(Farm, { 
  foreignKey: 'farm_id',
  as: 'farm'
});

// 养殖场与设备的一对多关系
Farm.hasMany(Device, { 
  foreignKey: 'farm_id',
  as: 'devices',
  onDelete: 'CASCADE',
  onUpdate: 'CASCADE'
});
Device.belongsTo(Farm, { 
  foreignKey: 'farm_id',
  as: 'farm'
});

// 养殖场与预警的一对多关系
Farm.hasMany(Alert, { 
  foreignKey: 'farm_id',
  as: 'alerts',
  onDelete: 'CASCADE',
  onUpdate: 'CASCADE'
});
Alert.belongsTo(Farm, { 
  foreignKey: 'farm_id',
  as: 'farm'
});

// 设备与预警的一对多关系
Device.hasMany(Alert, { 
  foreignKey: 'device_id',
  as: 'alerts',
  onDelete: 'CASCADE',
  onUpdate: 'CASCADE'
});
Alert.belongsTo(Device, { 
  foreignKey: 'device_id',
  as: 'device'
});

// 设备与传感器数据的一对多关系
Device.hasMany(SensorData, { 
  foreignKey: 'device_id',
  as: 'sensorData',
  onDelete: 'CASCADE',
  onUpdate: 'CASCADE'
});
SensorData.belongsTo(Device, { 
  foreignKey: 'device_id',
  as: 'device'
});

// 养殖场与传感器数据的一对多关系
Farm.hasMany(SensorData, { 
  foreignKey: 'farm_id',
  as: 'sensorData',
  onDelete: 'CASCADE',
  onUpdate: 'CASCADE'
});
SensorData.belongsTo(Farm, { 
  foreignKey: 'farm_id',
  as: 'farm'
});

// 用户与角色的多对多关系
User.belongsToMany(Role, { 
  through: UserRole, 
  foreignKey: 'user_id', 
  otherKey: 'role_id', 
  as: 'roles'
});
Role.belongsToMany(User, { 
  through: UserRole, 
  foreignKey: 'role_id', 
  otherKey: 'user_id', 
  as: 'users'
});

// 同步所有模型
const syncModels = async (options = {}) => {
  try {
    await sequelize.sync(options);
    console.log('所有模型已同步到数据库');
    return true;
  } catch (error) {
    console.error('模型同步失败:', error);
    return false;
  }
};

// 用户与订单的一对多关系
User.hasMany(Order, { 
  foreignKey: 'user_id',
  as: 'orders',
  onDelete: 'CASCADE',
  onUpdate: 'CASCADE'
});
Order.belongsTo(User, { 
  foreignKey: 'user_id',
  as: 'user'
});

// 订单与订单项的一对多关系
Order.hasMany(OrderItem, { 
  foreignKey: 'order_id',
  as: 'orderItems',
  onDelete: 'CASCADE',
  onUpdate: 'CASCADE'
});
OrderItem.belongsTo(Order, { 
  foreignKey: 'order_id',
  as: 'order'
});

// 产品与订单项的一对多关系
Product.hasMany(OrderItem, { 
  foreignKey: 'product_id',
  as: 'orderItems',
  onDelete: 'RESTRICT',
  onUpdate: 'CASCADE'
});
OrderItem.belongsTo(Product, { 
  foreignKey: 'product_id',
  as: 'product'
});

module.exports = {
  sequelize,
  BaseModel,
  Farm,
  Animal,
  Device,
  Alert,
  User,
  Role,
  UserRole,
  Product,
  Order,
  OrderItem,
  SensorData,
  syncModels
};