import User from './community/user.js';
import UserParam from './community/user_param.js';
import UserParamType from './type/user_param.js';
import UserRightType from './type/user_right.js';
import UserRight from './community/user_right.js';
import SettingsType from './type/settings.js';
import UserParamValue from './type/user_param_value.js';
import InterestType from './type/interest.js';
import InterestTranslationType from './type/interest_translation.js';
import Interest from './community/interest.js';
import UserParamVisibilityType from './type/user_param_visibility.js';
import UserParamVisibility from './community/user_param_visibility.js';
import Folder from './community/folder.js';
import Image from './community/image.js';
import ImageVisibilityType from './type/image_visibility.js';
import ImageVisibilityUser from './community/image_visibility_user.js';
import FolderImageVisibility from './community/folder_image_visibility.js';
import ImageImageVisibility from './community/image_image_visibility.js';
import FolderVisibilityUser from './community/folder_visibility_user.js';
import GuestbookEntry from './community/guestbook.js';
import Forum from './forum/forum.js';
import Title from './forum/title.js';
import Message from './forum/message.js';
import MessageImage from './forum/message_image.js';
import MessageHistory from './forum/message_history.js';
import TitleHistory from './forum/title_history.js';
import ForumPermission from './forum/forum_permission.js';
import ForumUserPermission from './forum/forum_user_permission.js';
import ForumForumPermission from './forum/forum_forum_permission.js';
import Friendship from './community/friendship.js';
import FalukantUser from './falukant/data/user.js';
import RegionType from './falukant/type/region.js';
import RegionData from './falukant/data/region.js';
import FalukantCharacter from './falukant/data/character.js';
import FalukantPredefineFirstname from './falukant/predefine/firstname.js';
import FalukantPredefineLastname from './falukant/predefine/lastname.js';
import FalukantStock from './falukant/data/stock.js';
import FalukantStockType from './falukant/type/stock.js';
import Knowledge from './falukant/data/product_knowledge.js';
import ProductType from './falukant/type/product.js';
import TitleOfNobility from './falukant/type/title_of_nobility.js';
import TitleRequirement from './falukant/type/title_requirement.js';
import Branch from './falukant/data/branch.js';
import BranchType from './falukant/type/branch.js';


export default function setupAssociations() {
    // UserParam related associations
    SettingsType.hasMany(UserParamType, { foreignKey: 'settingsId', as: 'user_param_types' });
    UserParamType.belongsTo(SettingsType, { foreignKey: 'settingsId', as: 'settings_type' });

    UserParamType.hasMany(UserParam, { foreignKey: 'paramTypeId', as: 'user_params' });
    UserParam.belongsTo(UserParamType, { foreignKey: 'paramTypeId', as: 'paramType' });

    User.hasMany(UserParam, { foreignKey: 'userId', as: 'user_params' });
    UserParam.belongsTo(User, { foreignKey: 'userId', as: 'user' });

    UserParamValue.belongsTo(UserParamType, { foreignKey: 'userParamTypeId', as: 'user_param_value_type' });
    UserParamType.hasMany(UserParamValue, { foreignKey: 'userParamTypeId', as: 'user_param_type_value' });

    UserRight.belongsTo(User, { foreignKey: 'userId', as: 'user_with_rights' });
    UserRight.belongsTo(UserRightType, { foreignKey: 'rightTypeId', as: 'rightType' });
    UserRightType.hasMany(UserRight, { foreignKey: 'rightTypeId', as: 'user_rights' });

    UserParam.hasMany(UserParamVisibility, { foreignKey: 'param_id', as: 'param_visibilities' });
    UserParamVisibility.belongsTo(UserParam, { foreignKey: 'param_id', as: 'param' });

    UserParamVisibility.belongsTo(UserParamVisibilityType, { foreignKey: 'visibility', as: 'visibility_type' });
    UserParamVisibilityType.hasMany(UserParamVisibility, { foreignKey: 'visibility', as: 'user_param_visibilities' });

    // Interest related associations
    InterestType.hasMany(InterestTranslationType, { foreignKey: 'interestsId', as: 'interest_translations' });
    InterestTranslationType.belongsTo(InterestType, { foreignKey: 'interestsId', as: 'interest_translations' });

    InterestType.hasMany(Interest, { foreignKey: 'userinterestId', as: 'user_interest_type' });
    User.hasMany(Interest, { foreignKey: 'userId', as: 'user_interests' });
    Interest.belongsTo(InterestType, { foreignKey: 'userinterestId', as: 'interest_type' });
    Interest.belongsTo(User, { foreignKey: 'userId', as: 'interest_owner' });

    // Folder and Image related associations
    Folder.belongsTo(User, { foreignKey: 'userId' });
    User.hasMany(Folder, { foreignKey: 'userId' });

    Folder.belongsTo(Folder, { foreignKey: 'parentId', as: 'parent' });
    Folder.hasMany(Folder, { foreignKey: 'parentId', as: 'children' });

    Image.belongsTo(Folder, { foreignKey: 'folderId' });
    Folder.hasMany(Image, { foreignKey: 'folderId' });

    Image.belongsTo(User, { foreignKey: 'userId' });
    User.hasMany(Image, { foreignKey: 'userId' });

    // Image visibility associations
    Folder.belongsToMany(ImageVisibilityType, {
        through: FolderImageVisibility,
        foreignKey: 'folderId',
        otherKey: 'visibilityTypeId'
    });
    ImageVisibilityType.belongsToMany(Folder, {
        through: FolderImageVisibility,
        foreignKey: 'visibilityTypeId',
        otherKey: 'folderId'
    });

    Image.belongsToMany(ImageVisibilityType, {
        through: ImageImageVisibility,
        foreignKey: 'imageId',
        otherKey: 'visibilityTypeId'
    });
    ImageVisibilityType.belongsToMany(Image, {
        through: ImageImageVisibility,
        foreignKey: 'visibilityTypeId',
        otherKey: 'imageId'
    });

    Folder.belongsToMany(ImageVisibilityUser, {
        through: FolderVisibilityUser,
        foreignKey: 'folderId',
        otherKey: 'visibilityUserId'
    });
    ImageVisibilityUser.belongsToMany(Folder, {
        through: FolderVisibilityUser,
        foreignKey: 'visibilityUserId',
        otherKey: 'folderId'
    });

    // Guestbook related associations
    User.hasMany(GuestbookEntry, { foreignKey: 'recipientId', as: 'receivedEntries' });
    User.hasMany(GuestbookEntry, { foreignKey: 'senderId', as: 'sentEntries' });
    GuestbookEntry.belongsTo(User, { foreignKey: 'recipientId', as: 'recipient' });
    GuestbookEntry.belongsTo(User, { foreignKey: 'senderId', as: 'sender' });

    // Forum related associations
    Forum.hasMany(Title, { foreignKey: 'forumId' });
    Title.belongsTo(Forum, { foreignKey: 'forumId' });

    Title.belongsTo(User, { foreignKey: 'createdBy', as: 'createdByUser' });
    User.hasMany(Title, { foreignKey: 'createdBy', as: 'titles' });

    Title.hasMany(Message, { foreignKey: 'titleId', as: 'messages' });
    Message.belongsTo(Title, { foreignKey: 'titleId', as: 'title' });

    Message.belongsTo(User, { foreignKey: 'createdBy', as: 'lastMessageUser' });
    User.hasMany(Message, { foreignKey: 'createdBy', as: 'userMessages' });

    Message.hasMany(MessageImage, { foreignKey: 'messageId' });
    MessageImage.belongsTo(Message, { foreignKey: 'messageId' });

    Message.hasMany(MessageHistory, { foreignKey: 'messageId' });
    MessageHistory.belongsTo(Message, { foreignKey: 'messageId' });

    Title.hasMany(TitleHistory, { foreignKey: 'titleId' });
    TitleHistory.belongsTo(Title, { foreignKey: 'titleId' });

    // Forum permissions associations
    Forum.hasMany(ForumUserPermission, { foreignKey: 'forumId', as: 'userPermissions' });
    ForumUserPermission.belongsTo(Forum, { foreignKey: 'forumId' });

    User.hasMany(ForumUserPermission, { foreignKey: 'userId', as: 'userPermissions' });
    ForumUserPermission.belongsTo(User, { foreignKey: 'userId' });

    Forum.belongsToMany(ForumPermission, {
        through: ForumForumPermission,
        foreignKey: 'forumId',
        as: 'associatedPermissions'
    });

    ForumPermission.belongsToMany(Forum, {
        through: ForumForumPermission,
        foreignKey: 'permissionId',
        as: 'forums'
    });

    ForumPermission.hasMany(ForumUserPermission, { foreignKey: 'permissionId' });
    ForumUserPermission.belongsTo(ForumPermission, { foreignKey: 'permissionId' });

    Friendship.belongsTo(User, { foreignKey: 'user1Id', as: 'friendSender' });
    Friendship.belongsTo(User, { foreignKey: 'user2Id', as: 'friendReceiver' });
    User.hasMany(Friendship, { foreignKey: 'user1Id', as: 'friendSender' });
    User.hasMany(Friendship, { foreignKey: 'user2Id', as: 'friendReceiver' });

    User.hasMany(FalukantUser, { foreignKey: 'userId', as: 'falukantData' });
    FalukantUser.belongsTo(User, { foreignKey: 'userId', as: 'user' });

    RegionType.hasMany(RegionType, { foreignKey: 'parentId', as: 'children' });
    RegionType.belongsTo(RegionType, { foreignKey: 'parentId', as: 'parent' });

    RegionData.hasMany(RegionData, { foreignKey: 'parentId', as: 'children' });
    RegionData.belongsTo(RegionData, { foreignKey: 'parentId', as: 'parent' });

    RegionData.belongsTo(RegionType, { foreignKey: 'regionTypeId', as: 'regionType' });
    RegionType.hasMany(RegionData, { foreignKey: 'regionTypeId', as: 'regions' });

    FalukantUser.belongsTo(RegionData, { foreignKey: 'mainBranchRegionId', as: 'mainBranchRegion' });
    RegionData.hasMany(FalukantUser, { foreignKey: 'mainBranchRegionId', as: 'users' });

    FalukantCharacter.belongsTo(FalukantUser, { foreignKey: 'userId', as: 'user' });
    FalukantUser.hasOne(FalukantCharacter, { foreignKey: 'userId', as: 'character' });

    FalukantCharacter.belongsTo(FalukantPredefineFirstname, { foreignKey: 'firstName', as: 'definedFirstName' });
    FalukantPredefineFirstname.hasMany(FalukantCharacter, { foreignKey: 'firstName', as: 'charactersWithFirstName' });

    FalukantCharacter.belongsTo(FalukantPredefineLastname, { foreignKey: 'lastName', as: 'definedLastName' });
    FalukantPredefineLastname.hasMany(FalukantCharacter, { foreignKey: 'lastName', as: 'charactersWithLastName' });

    FalukantCharacter.belongsTo(TitleOfNobility, { foreignKey: 'titleOfNobility', as: 'nobleTitle' });
    TitleOfNobility.hasMany(FalukantCharacter, { foreignKey: 'titleOfNobility', as: 'charactersWithNobleTitle' });
    
    FalukantCharacter.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
    RegionData.hasMany(FalukantCharacter, { foreignKey: 'regionId', as: 'charactersInRegion' });

    FalukantStock.belongsTo(FalukantStockType, { foreignKey: 'stockTypeId', as: 'stockType' });
    FalukantStockType.hasMany(FalukantStock, { foreignKey: 'stockTypeId', as: 'stocks' });

    FalukantStock.belongsTo(FalukantUser, { foreignKey: 'userId', as: 'user' });
    FalukantUser.hasMany(FalukantStock, { foreignKey: 'userId', as: 'stocks' });

    FalukantStock.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
    RegionData.hasMany(FalukantStock, { foreignKey: 'regionId', as: 'stocksInRegion' });

    Knowledge.belongsTo(ProductType, { foreignKey: 'productTypeId', as: 'productType' });
    ProductType.hasMany(Knowledge, { foreignKey: 'productTypeId', as: 'knowledges' });

    Knowledge.belongsTo(FalukantCharacter, { foreignKey: 'characterId', as: 'character' });
    FalukantCharacter.hasMany(Knowledge, { foreignKey: 'characterId', as: 'knowledges' });

    TitleRequirement.belongsTo(TitleOfNobility, { foreignKey: 'titleId', as: 'title' });
    TitleOfNobility.hasMany(TitleRequirement, { foreignKey: 'titleId', as: 'requirements' });

    Branch.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
    RegionData.hasMany(Branch, { foreignKey: 'regionId', as: 'branches' });

    Branch.belongsTo(FalukantUser, { foreignKey: 'falukantUserId', as: 'user' });
    FalukantUser.hasMany(Branch, { foreignKey: 'falukantUserId', as: 'branches' });

    Branch.belongsTo(BranchType, { foreignKey: 'branchTypeId', as: 'branchType' });
    BranchType.hasMany(Branch, { foreignKey: 'branchTypeId', as: 'branches' });
}