import AdminBadgesViewModel from "../models/admin/AdminBadgesViewModel";
import AdminBadgeViewModel from "../models/admin/AdminBadgeViewModel";
import AdminDeleteBadgeModel from "../models/admin/AdminDeleteBadgeModel";
import AdminDeletePartyModel from "../models/admin/AdminDeletePartyModel";
import AdminExpireSessionModel from "../models/admin/AdminExpireSessionModel";
import AdminIndexViewModel from "../models/admin/AdminIndexViewModel";
import AdminPartiesViewModel from "../models/admin/AdminPartiesViewModel";
import AdminPartyViewModel from "../models/admin/AdminPartyViewModel";
import AdminUserBadgesViewModel from "../models/admin/AdminUserBadgesViewModel";
import AdminUsersViewModel from "../models/admin/AdminUsersViewModel";
import AdminUserViewModel from "../models/admin/AdminUserViewModel";
import AdminWebSessionsViewModel from "../models/admin/AdminWebSessionsViewModel";
import AdminWsSessionsViewModel from "../models/admin/AdminWsSessionsViewModel";
import FunkyArray from "funky-array";
import Session from "../objects/Session";
import WsData from "../objects/WsData";
import BadgeService from "../services/BadgeService";
import PartyService from "../services/PartyService";
import UserService from "../services/UserService";
import Controller from "./Controller";
import UserBadgeListItem from "../entities/list/UserBadgeListItem";
import AdminRemoveUserBadgeModel from "../models/admin/AdminRemoveUserBadgeModel";
import OverrideService from "../services/OverrideService";
import AdminOverridesViewModel from "../models/admin/AdminOverridesViewModel";
import AdminOverrideViewModel from "../models/admin/AdminOverrideViewModel";
import OverrideType from "../enums/OverrideType";
import AdminOverrideData from "../models/admin/AdminOverrideData";

export default class AdminController_Auth$Admin extends Controller {
	public async Index_Get() {
		const adminIndexViewModel: AdminIndexViewModel = {
			userCount: await UserService.GetUserCount(),
			partyCount: await PartyService.GetPartyCount(),
			badgeCount: await BadgeService.GetBadgeCount(),
			userBadgeCount: await BadgeService.GetUnlockedBadgeCount()
		};

		return this.view(adminIndexViewModel);
	}

	public async Users_Get() {
		const adminUsersViewModel: AdminUsersViewModel = {
			users: await UserService.GetAll()
		};

		return this.view(adminUsersViewModel);
	}

	public async User_Get(adminUserViewModel: AdminUserViewModel) {
		const user = adminUserViewModel.id ? await UserService.GetUser(parseInt(adminUserViewModel.id)) : null;
		if (typeof adminUserViewModel.id !== "undefined" && user) {
			adminUserViewModel.username = user.Username;
			adminUserViewModel.userLevel = String(user.UserLevel);
		} else {
			adminUserViewModel.username = "";
			adminUserViewModel.userLevel = "0";
		}

		return this.view(adminUserViewModel);
	}

	public async User_Post(adminUserViewModel: AdminUserViewModel) {
		if (typeof adminUserViewModel.id === "undefined") {
			return this.badRequest();
		}

		const user = await UserService.SaveUser(this.session.userId, parseInt(adminUserViewModel.id), adminUserViewModel.username ?? "", parseInt(adminUserViewModel.userLevel ?? ""));
		if (!user) {
			adminUserViewModel.message = "A user with that username already exists.";
			return this.view(adminUserViewModel);
		}

		return this.redirectToAction("users");
	}

	public async Parties_Get() {
		const adminPartiesViewModel: AdminPartiesViewModel = {
			parties: await PartyService.GetAll()
		};

		return this.view(adminPartiesViewModel);
	}

	public async Party_Get(adminPartyViewModel: AdminPartyViewModel) {
		const party = adminPartyViewModel.id ? await PartyService.GetParty(parseInt(adminPartyViewModel.id)) : null;
		if (typeof adminPartyViewModel.id !== "undefined" && party) {
			adminPartyViewModel.partyRef = party.PartyRef;
			adminPartyViewModel.name = party.Name;
		} else {
			adminPartyViewModel.partyRef = "";
			adminPartyViewModel.name = "";
		}

		return this.view(adminPartyViewModel);
	}

	public async Party_Post(adminPartyViewModel: AdminPartyViewModel) {
		if (typeof adminPartyViewModel.id === "undefined") {
			return this.badRequest();
		}

		await PartyService.SaveParty(this.session.userId, parseInt(adminPartyViewModel.id), adminPartyViewModel.name ?? "", adminPartyViewModel.partyRef ?? "");

		return this.redirectToAction("parties");
	}

	public async DeleteParty_Get(adminDeletePartyModel: AdminDeletePartyModel) {
		if (typeof adminDeletePartyModel.id === "undefined" || typeof adminDeletePartyModel.id !== "string") {
			return this.badRequest();
		}
		const partyId = parseInt(adminDeletePartyModel.id);

		await PartyService.DeletePartyAdmin(this.session.userId, partyId);

		return this.redirectToAction("parties");
	}

	public async Badges_Get_Auth$BadgeEditor() {
		const adminBadgesViewModel: AdminBadgesViewModel = {
			badges: await BadgeService.LoadAll()
		};

		return this.view(adminBadgesViewModel);
	}

	public async Badge_Get_Auth$BadgeEditor(adminBadgeViewModel: AdminBadgeViewModel) {
		const badge = adminBadgeViewModel.id ? await BadgeService.LoadBadge(parseInt(adminBadgeViewModel.id)) : null;
		if (typeof adminBadgeViewModel.id !== "undefined" && badge) {
			adminBadgeViewModel.name = badge.Name;
			adminBadgeViewModel.description = badge.Description;
			adminBadgeViewModel.hint = badge.Hint;
			adminBadgeViewModel.imageUrl = badge.ImageUrl;
			adminBadgeViewModel.forUrl = badge.ForUrl;
			adminBadgeViewModel.isSecret = badge.IsSecret;
		} else {
			adminBadgeViewModel.name = "";
			adminBadgeViewModel.description = "";
			adminBadgeViewModel.hint = "";
			adminBadgeViewModel.imageUrl = "";
			adminBadgeViewModel.forUrl = "";
			adminBadgeViewModel.isSecret = false;
		}

		return this.view(adminBadgeViewModel);
	}

	public async Badge_Post_Auth$BadgeEditor(adminBadgeViewModel: AdminBadgeViewModel) {
		if (typeof adminBadgeViewModel.id === "undefined") {
			return this.badRequest();
		}

		await BadgeService.SaveBadge(this.session.userId, parseInt(adminBadgeViewModel.id), adminBadgeViewModel.name ?? "", adminBadgeViewModel.description ?? "", adminBadgeViewModel.hint ?? "", adminBadgeViewModel.imageUrl ?? "", adminBadgeViewModel.forUrl ?? "", (adminBadgeViewModel.isSecret?.toString() ?? "") === "on");

		return this.redirectToAction("badges");
	}

	public async DeleteBadge_Get_Auth$BadgeEditor(adminDeleteBadgeModel: AdminDeleteBadgeModel) {
		if (typeof adminDeleteBadgeModel.id === "undefined" || typeof adminDeleteBadgeModel.id !== "string") {
			return this.badRequest();
		}
		const badgeId = parseInt(adminDeleteBadgeModel.id);

		await BadgeService.DeleteBadge(this.session.userId, badgeId);

		return this.redirectToAction("badges");
	}

	public async WebSessions_Get() {
		const adminWebSessionsViewModel: AdminWebSessionsViewModel = {
			sessions: Session.Sessions
		};

		return this.view(adminWebSessionsViewModel);
	}

	public async ExpireSession_Get(adminExpireSessionModel: AdminExpireSessionModel) {
		if (typeof adminExpireSessionModel.key === "undefined" || typeof adminExpireSessionModel.key !== "string") {
			return this.badRequest();
		}

		Session.Sessions.remove(adminExpireSessionModel.key);

		return this.redirectToAction("websessions");
	}

	public async WsSessions_Get() {
		const adminWsSessionsViewModel: AdminWsSessionsViewModel = {
			users: WsData.users
		};

		return this.view(adminWsSessionsViewModel);
	}

	public async UserBadges_Get(adminUserBadgesViewModel: AdminUserBadgesViewModel) {
		const unlockedBadgeListItems = await BadgeService.GetUnlockedBadgeList(adminUserBadgesViewModel.badgeq, adminUserBadgesViewModel.userq);

		const unlockedBadgeByBadgeId = new FunkyArray<number, Array<UserBadgeListItem>>();
		let unlockedBadgeByBadgeIdArray: Array<UserBadgeListItem> | undefined;
		for (const unlockedBadgeListItem of unlockedBadgeListItems) {
			if (!(unlockedBadgeByBadgeIdArray = unlockedBadgeByBadgeId.get(unlockedBadgeListItem.BadgeId))) {
				unlockedBadgeByBadgeId.set(unlockedBadgeListItem.BadgeId, (unlockedBadgeByBadgeIdArray = new Array<UserBadgeListItem>()));
			}

			unlockedBadgeByBadgeIdArray.push(unlockedBadgeListItem);
		}

		adminUserBadgesViewModel.badges = await BadgeService.LoadList(adminUserBadgesViewModel.badgeq);
		adminUserBadgesViewModel.unlockByBadgeId = unlockedBadgeByBadgeId;

		return this.view(adminUserBadgesViewModel);
	}

	public async RemoveUserBadge_Get(adminRemoveUserBadgeModel: AdminRemoveUserBadgeModel) {
		if (typeof adminRemoveUserBadgeModel.id === "undefined" || typeof adminRemoveUserBadgeModel.id !== "string") {
			return this.badRequest();
		}
		const userBadgeId = parseInt(adminRemoveUserBadgeModel.id);

		UserService.DeleteUnlockedBadge(this.session.userId, userBadgeId);

		return this.redirectToAction("userbadges");
	}

	public async Overrides_Get() {
		const adminOverridesViewModel: AdminOverridesViewModel = {
			overrides: await OverrideService.GetOverrides()
		};

		return this.view(adminOverridesViewModel);
	}

	public async Override_Get(adminOverrideViewModel: AdminOverrideViewModel) {
		const override = adminOverrideViewModel.id ? await OverrideService.GetOverride(parseInt(adminOverrideViewModel.id)) : null;
		if (typeof adminOverrideViewModel.id !== "undefined" && override) {
			adminOverrideViewModel.overrideType = override.OverrideType;
			adminOverrideViewModel.name = override.Name;
			adminOverrideViewModel.forUrl = override.ForURL;
			adminOverrideViewModel.cssQuery = override.CSSQuery;
		} else {
			adminOverrideViewModel.overrideType = OverrideType.Unknown;
			adminOverrideViewModel.name = "";
			adminOverrideViewModel.forUrl = "";
			adminOverrideViewModel.cssQuery = "";
		}

		return this.view(adminOverrideViewModel);
	}

	public OverrideAddHtml_Get() {
		return this.view("_addhtml");
	}

	public async Override_Post(adminOverrideData: AdminOverrideData) {
		if (typeof adminOverrideData.id === "undefined") {
			return this.badRequest();
		}

		await OverrideService.SaveOverride(this.session.userId, parseInt(adminOverrideData.id), parseInt(adminOverrideData.overrideType), adminOverrideData.name, adminOverrideData.forUrl, adminOverrideData.cssQuery);
		for (const customField of adminOverrideData.customFields) {
		}

		return this.redirectToAction("override");
	}
}