import RoomType from '../models/chat/room_type.js';
import ChatRight from '../models/chat/rights.js';
import UserRight from "../models/community/user_right.js";
import UserRightType from "../models/type/user_right.js";
import InterestType from "../models/type/interest.js";
import InterestTranslationType from "../models/type/interest_translation.js";
import User from "../models/community/user.js";
import UserParamValue from "../models/type/user_param_value.js";
import UserParamType from "../models/type/user_param.js";
import ContactMessage from "../models/service/contactmessage.js";
import ContactService from "./ContactService.js";
import { sendAnswerEmail } from './emailService.js';
import { Op } from 'sequelize';
import FalukantUser from "../models/falukant/data/user.js";
import FalukantCharacter from "../models/falukant/data/character.js";
import FalukantPredefineFirstname from "../models/falukant/predefine/firstname.js";
import FalukantPredefineLastname from "../models/falukant/predefine/lastname.js";
import Room from '../models/chat/room.js';

class AdminService {
    async hasUserAccess(userId, section) {
        const userRights = await UserRight.findAll({
            include: [{
                model: UserRightType,
                as: 'rightType',
                where: {
                    title: [section, 'mainadmin'],
                }
            },
            {
                model: User,
                as: 'user_with_rights',
                where: {
                    hashedId: userId,
                }
            }
            ]

        });
        return userRights.length > 0;
    }

    async getOpenInterests(userId) {
        if (!this.hasUserAccess(userId, 'interests')) {
            throw new Error('noaccess');
        }
        const openInterests = await InterestType.findAll({
            where: {
                allowed: false
            },
            include: {
                model: InterestTranslationType,
                as: 'interest_translations',
            }
        })
        return openInterests;
    }

    async changeInterest(userId, interestId, active, adultOnly) {
        if (!this.hasUserAccess(userId, 'interests')) {
            throw new Error('noaccess');
        }
        const interest = await InterestType.findOne({
            where: {
                id: interestId
            }
        });
        if (interest) {
            interest.allowed = active;
            interest.adultOnly = adultOnly;
            await interest.save();
        }
    }

    async deleteInterest(userId, interestId) {
        if (!this.hasUserAccess(userId, 'interests')) {
            throw new Error('noaccess');
        }
        const interest = await InterestType.findOne({
            where: {
                id: interestId
            }
        });
        if (interest) {
            await interest.destroy();
        }
    }

    async changeTranslation(userId, interestId, translations) {
        if (!this.hasUserAccess(userId, 'interests')) {
            throw new Error('noaccess');
        }
        const interest = await InterestType.findOne({
            id: interestId
        });
        if (!interest) {
            throw new Error('notexisting');
        }
        for (const languageId of Object.keys(translations)) {
            const languageObject = await UserParamValue.findOne(
                {
                    where: {
                        id: languageId
                    }
                }
            );
            if (!languageObject) {
                throw new Error('wronglanguage');
            }
            const translation = await InterestTranslationType.findOne(
                {
                    where: {
                        interestsId: interestId,
                        language: languageObject.id
                    }
                }
            );
            if (translation) {
                translation.translation = translations[languageId];
                translation.save();
            } else {
                await InterestTranslationType.create({
                    interestsId: interestId,
                    language: languageObject.id,
                    translation: translations[languageId]

                });
            }
        }
    }

    async getOpenContacts(userId) {
        if (!this.hasUserAccess(userId, 'contacts')) {
            throw new Error('noaccess');
        }
        const openContacts = await ContactMessage.findAll({
            where: {
                isFinished: false,
            }
        })
        return openContacts;
    }

    async answerContact(contactId, answer) {
        const contact = await ContactService.getContactById(contactId);
        await ContactService.saveAnswer(contact, answer);
        await sendAnswerEmail(contact.email, answer, contact.language || 'en');
    }

    async getFalukantUser(userId, userName, characterName) {
        if (!(await this.hasUserAccess(userId, 'falukantusers'))) {
            throw new Error('noaccess');
        }
        let users;
        if (userName) {
            users = await User.findAll({
                where: {
                    username: {
                        [Op.like]: '%' + userName + '%'
                    }
                },
                include: [{
                    model: FalukantUser,
                    as: 'falukantData',
                    required: true,
                    include: [{
                        model: FalukantCharacter,
                        as: 'character',
                        required: true,
                        include: [{
                            model: FalukantPredefineFirstname,
                            as: 'definedFirstName',
                            required: true
                        }, {
                            model: FalukantPredefineLastname,
                            as: 'definedLastName',
                            required: true
                        }]
                    }]
                }]
            });
        } else if (characterName) {
            const [firstname, lastname] = characterName.split(' ');
            users = await User.findAll({
                include: [{
                    model: FalukantUser,
                    as: 'falukantData',
                    required: true,
                    include: [{
                        model: FalukantCharacter,
                        as: 'character',
                        required: true,
                        include: [{
                            model: FalukantPredefineFirstname,
                            as: 'definedFirstName',
                            required: true,
                            where: {
                                name: firstname
                            }
                        }, {
                            model: FalukantPredefineLastname,
                            as: 'definedLastName',
                            required: true,
                            where: {
                                name: lastname
                            }
                        }]
                    }]
                }]
            });
        } else {
            throw new Error('no search parameter');
        }
        return users.map(user => {
            return {
                id: user.hashedId,
                username: user.username,
                falukantUser: user.falukantData
            }
        });
    }

    async getFalukantUserById(userId, hashedId) {
        if (!(await this.hasUserAccess(userId, 'falukantusers'))) {
            throw new Error('noaccess');
        }
        const user = await User.findOne({
            where: {
                hashedId: hashedId
            },
            attributes: ['hashedId', 'username'],
            include: [{
                model: FalukantUser,
                as: 'falukantData',
                required: true,
                attributes: ['money', 'certificate', 'id'],
                include: [{
                    model: FalukantCharacter,
                    as: 'character',
                    attributes: ['birthdate', 'health', 'title_of_nobility'],
                    include: [{
                        model: FalukantPredefineFirstname,
                        as: 'definedFirstName',
                    }, {
                        model: FalukantPredefineLastname,
                        as: 'definedLastName',
                    }]
                }]
            }]
        });
        return user;
    }

    async changeFalukantUser(userId, falukantUserId, falukantData) {
        if (!(await this.hasUserAccess(userId, 'falukantusers'))) {
            throw new Error('noaccess');
        }
        const falukantUser = await FalukantUser.findOne({
            where: {
                id: falukantUserId
            }
        });
        if (!falukantUser) {
            throw new Error('notfound');
        }
        const character = await FalukantCharacter.findOne({
            where: {
                userId: falukantUserId
            }
        });
        if (!character) {
            throw new Error('notfound');
        }
        if (Object.keys(falukantData).indexOf('age') >= 0) {
            const birthDate = (new Date()) - (falukantData.age * 24 * 3600000);
            await character.update({
                birthdate: birthDate
            });
        }
        if (Object.keys(falukantData).indexOf('money')  >= 0) {
            await falukantUser.update({
                money: falukantData.money
            });
        }
        if (Object.keys(falukantData).indexOf('title_of_nobility') >= 0) {
            await character.update({
                titleOfNobility: falukantData.title_of_nobility
            });
        }
        await falukantUser.save();
        await character.save();
    }

    // --- Chat Room Admin ---
    async getRoomTypes() {
        return await RoomType.findAll();
    }

    async getGenderRestrictions() {
        // Find the UserParamType for gender restriction (e.g. description = 'gender')
        const genderType = await UserParamType.findOne({ where: { description: 'gender' } });
        if (!genderType) return [];
        return await UserParamValue.findAll({ where: { userParamTypeId: genderType.id } });
    }

    async getUserRights() {
        return await ChatRight.findAll();
    }

    async getRooms() {
        // Only return necessary fields to the frontend
        return await Room.findAll({
            attributes: [
                'id',
                'title',
                'roomTypeId',
                'isPublic',
                'genderRestrictionId',
                'minAge',
                'maxAge',
                'friendsOfOwnerOnly',
                'requiredUserRightId',
                'password' // only if needed for editing, otherwise remove
            ],
            include: [
                { model: RoomType, as: 'roomType' },
                { model: UserParamValue, as: 'genderRestriction' },
            ]
        });
    }

    async updateRoom(id, data) {
        const room = await Room.findByPk(id);
        if (!room) throw new Error('Room not found');
        await room.update(data);
        return room;
    }

    async createRoom(data) {
        return await Room.create(data);
    }

    async deleteRoom(id) {
        return await Room.destroy({ where: { id } });
    }
}

export default new AdminService();