var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
    var _, done = false;
    for (var i = decorators.length - 1; i >= 0; i--) {
        var context = {};
        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
        if (kind === "accessor") {
            if (result === void 0) continue;
            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
            if (_ = accept(result.get)) descriptor.get = _;
            if (_ = accept(result.set)) descriptor.set = _;
            if (_ = accept(result.init)) initializers.unshift(_);
        }
        else if (_ = accept(result)) {
            if (kind === "field") initializers.unshift(_);
            else descriptor[key] = _;
        }
    }
    if (target) Object.defineProperty(target, contextIn.name, descriptor);
    done = true;
};
var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
    var useValue = arguments.length > 2;
    for (var i = 0; i < initializers.length; i++) {
        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
    }
    return useValue ? value : void 0;
};
import * as plugins from '../plugins.js';
import * as appstate from '../appstate.js';
import * as interfaces from '../../dist_ts_interfaces/index.js';
import { appRouter } from '../router.js';
import { DeesElement, css, cssManager, customElement, html, state } from '@design.estate/dees-element';
// Import view components
import { OpsViewOverview } from './ops-view-overview.js';
import { OpsViewNetwork } from './ops-view-network.js';
import { OpsViewEmails } from './ops-view-emails.js';
import { OpsViewLogs } from './ops-view-logs.js';
import { OpsViewConfig } from './ops-view-config.js';
import { OpsViewRoutes } from './ops-view-routes.js';
import { OpsViewApiTokens } from './ops-view-apitokens.js';
import { OpsViewSecurity } from './ops-view-security.js';
import { OpsViewCertificates } from './ops-view-certificates.js';
import { OpsViewRemoteIngress } from './ops-view-remoteingress.js';
import { OpsViewVpn } from './ops-view-vpn.js';
import { OpsViewSecurityProfiles } from './ops-view-securityprofiles.js';
import { OpsViewNetworkTargets } from './ops-view-networktargets.js';
let OpsDashboard = (() => {
    let _classDecorators = [customElement('ops-dashboard')];
    let _classDescriptor;
    let _classExtraInitializers = [];
    let _classThis;
    let _classSuper = DeesElement;
    let _loginState_decorators;
    let _loginState_initializers = [];
    let _loginState_extraInitializers = [];
    let _uiState_decorators;
    let _uiState_initializers = [];
    let _uiState_extraInitializers = [];
    let _configState_decorators;
    let _configState_initializers = [];
    let _configState_extraInitializers = [];
    var OpsDashboard = class extends _classSuper {
        static { _classThis = this; }
        static {
            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
            _loginState_decorators = [state()];
            _uiState_decorators = [state()];
            _configState_decorators = [state()];
            __esDecorate(this, null, _loginState_decorators, { kind: "accessor", name: "loginState", static: false, private: false, access: { has: obj => "loginState" in obj, get: obj => obj.loginState, set: (obj, value) => { obj.loginState = value; } }, metadata: _metadata }, _loginState_initializers, _loginState_extraInitializers);
            __esDecorate(this, null, _uiState_decorators, { kind: "accessor", name: "uiState", static: false, private: false, access: { has: obj => "uiState" in obj, get: obj => obj.uiState, set: (obj, value) => { obj.uiState = value; } }, metadata: _metadata }, _uiState_initializers, _uiState_extraInitializers);
            __esDecorate(this, null, _configState_decorators, { kind: "accessor", name: "configState", static: false, private: false, access: { has: obj => "configState" in obj, get: obj => obj.configState, set: (obj, value) => { obj.configState = value; } }, metadata: _metadata }, _configState_initializers, _configState_extraInitializers);
            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
            OpsDashboard = _classThis = _classDescriptor.value;
            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
        }
        #loginState_accessor_storage = __runInitializers(this, _loginState_initializers, {
            identity: null,
            isLoggedIn: false,
        });
        get loginState() { return this.#loginState_accessor_storage; }
        set loginState(value) { this.#loginState_accessor_storage = value; }
        #uiState_accessor_storage = (__runInitializers(this, _loginState_extraInitializers), __runInitializers(this, _uiState_initializers, {
            activeView: 'overview',
            sidebarCollapsed: false,
            autoRefresh: true,
            refreshInterval: 1000,
            theme: 'light',
        }));
        get uiState() { return this.#uiState_accessor_storage; }
        set uiState(value) { this.#uiState_accessor_storage = value; }
        #configState_accessor_storage = (__runInitializers(this, _uiState_extraInitializers), __runInitializers(this, _configState_initializers, {
            config: null,
            isLoading: false,
            error: null,
        }));
        get configState() { return this.#configState_accessor_storage; }
        set configState(value) { this.#configState_accessor_storage = value; }
        // Store viewTabs as a property to maintain object references
        viewTabs = (__runInitializers(this, _configState_extraInitializers), [
            {
                name: 'Overview',
                iconName: 'lucide:layoutDashboard',
                element: OpsViewOverview,
            },
            {
                name: 'Configuration',
                iconName: 'lucide:settings',
                element: OpsViewConfig,
            },
            {
                name: 'Network',
                iconName: 'lucide:network',
                element: OpsViewNetwork,
            },
            {
                name: 'Emails',
                iconName: 'lucide:mail',
                element: OpsViewEmails,
            },
            {
                name: 'Logs',
                iconName: 'lucide:scrollText',
                element: OpsViewLogs,
            },
            {
                name: 'Routes',
                iconName: 'lucide:route',
                element: OpsViewRoutes,
            },
            {
                name: 'SecurityProfiles',
                iconName: 'lucide:shieldCheck',
                element: OpsViewSecurityProfiles,
            },
            {
                name: 'NetworkTargets',
                iconName: 'lucide:server',
                element: OpsViewNetworkTargets,
            },
            {
                name: 'ApiTokens',
                iconName: 'lucide:key',
                element: OpsViewApiTokens,
            },
            {
                name: 'Security',
                iconName: 'lucide:shield',
                element: OpsViewSecurity,
            },
            {
                name: 'Certificates',
                iconName: 'lucide:badgeCheck',
                element: OpsViewCertificates,
            },
            {
                name: 'RemoteIngress',
                iconName: 'lucide:globe',
                element: OpsViewRemoteIngress,
            },
            {
                name: 'VPN',
                iconName: 'lucide:shield',
                element: OpsViewVpn,
            },
        ]);
        get globalMessages() {
            const messages = [];
            const config = this.configState.config;
            if (config && !config.cache.enabled) {
                messages.push({
                    id: 'db-disabled',
                    type: 'warning',
                    message: 'Database is disabled. Creating and editing routes, profiles, targets, and API tokens is not available.',
                    dismissible: false,
                });
            }
            return messages;
        }
        /**
         * Get the current view tab based on the UI state's activeView.
         * Used to pass the correct selectedView to dees-simple-appdash on initial render.
         */
        get currentViewTab() {
            return this.viewTabs.find(t => t.name.toLowerCase() === this.uiState.activeView) || this.viewTabs[0];
        }
        constructor() {
            super();
            document.title = 'DCRouter OpsServer';
            // Subscribe to login state
            const loginSubscription = appstate.loginStatePart
                .select((stateArg) => stateArg)
                .subscribe((loginState) => {
                this.loginState = loginState;
                // Trigger data fetch when logged in
                if (loginState.isLoggedIn) {
                    appstate.statsStatePart.dispatchAction(appstate.fetchAllStatsAction, null);
                    appstate.configStatePart.dispatchAction(appstate.fetchConfigurationAction, null);
                }
            });
            this.rxSubscriptions.push(loginSubscription);
            // Subscribe to config state (for global warnings)
            const configSubscription = appstate.configStatePart
                .select((stateArg) => stateArg)
                .subscribe((configState) => {
                this.configState = configState;
            });
            this.rxSubscriptions.push(configSubscription);
            // Subscribe to UI state
            const uiSubscription = appstate.uiStatePart
                .select((stateArg) => stateArg)
                .subscribe((uiState) => {
                this.uiState = uiState;
                // Sync appdash view when state changes (e.g., from URL navigation)
                this.syncAppdashView(uiState.activeView);
            });
            this.rxSubscriptions.push(uiSubscription);
        }
        /**
         * Sync the dees-simple-appdash view selection with the current state.
         * This is needed when the URL changes and we need to update the UI.
         */
        syncAppdashView(viewName) {
            const appDash = this.shadowRoot?.querySelector('dees-simple-appdash');
            if (!appDash)
                return;
            const targetTab = this.viewTabs.find(t => t.name.toLowerCase() === viewName);
            if (!targetTab)
                return;
            // Check if we need to switch (avoid unnecessary updates)
            if (appDash.selectedView === targetTab)
                return;
            // Update the selected view programmatically
            appDash.selectedView = targetTab;
            // Update the displayed content
            const content = appDash.shadowRoot?.querySelector('.appcontent');
            if (content) {
                if (appDash.currentView) {
                    appDash.currentView.remove();
                }
                const view = new targetTab.element();
                content.appendChild(view);
                appDash.currentView = view;
            }
        }
        static styles = [
            cssManager.defaultStyles,
            css `
      :host {
        display: block;
        width: 100%;
        height: 100vh;
        overflow: hidden;
      }

      .maincontainer {
        position: relative;
        width: 100%;
        height: 100%;
      }
    `,
        ];
        render() {
            return html `
      <div class="maincontainer">
        <dees-simple-login
          name="DCRouter OpsServer"
        >
          <dees-simple-appdash
            name="DCRouter OpsServer"
            .viewTabs=${this.viewTabs}
            .selectedView=${this.currentViewTab}
            .globalMessages=${this.globalMessages}
          >
          </dees-simple-appdash>
        </dees-simple-login>
      </div>
    `;
        }
        async firstUpdated() {
            const simpleLogin = this.shadowRoot.querySelector('dees-simple-login');
            simpleLogin.addEventListener('login', (e) => {
                // Handle logout event
                const detail = e.detail;
                this.login(detail.data.username, detail.data.password);
            });
            // Handle view changes
            const appDash = this.shadowRoot.querySelector('dees-simple-appdash');
            if (appDash) {
                appDash.addEventListener('view-select', (e) => {
                    const viewName = e.detail.view.name.toLowerCase();
                    // Use router for navigation instead of direct state update
                    appRouter.navigateToView(viewName);
                });
                // Handle logout event
                appDash.addEventListener('logout', async () => {
                    await appstate.loginStatePart.dispatchAction(appstate.logoutAction, null);
                });
            }
            // Handle initial state - check if we have a stored session that's still valid
            const loginState = appstate.loginStatePart.getState();
            if (loginState.identity?.jwt) {
                if (loginState.identity.expiresAt > Date.now()) {
                    // Client-side expiry looks valid — verify with server (keypair may have changed)
                    try {
                        const verifyRequest = new plugins.domtools.plugins.typedrequest.TypedRequest('/typedrequest', 'verifyIdentity');
                        const response = await verifyRequest.fire({ identity: loginState.identity });
                        if (response.valid) {
                            // JWT confirmed valid by server
                            this.loginState = loginState;
                            await simpleLogin.switchToSlottedContent();
                            await appstate.statsStatePart.dispatchAction(appstate.fetchAllStatsAction, null);
                            await appstate.configStatePart.dispatchAction(appstate.fetchConfigurationAction, null);
                        }
                        else {
                            // Server rejected the JWT — clear state, show login
                            await appstate.loginStatePart.dispatchAction(appstate.logoutAction, null);
                        }
                    }
                    catch {
                        // Server unreachable or error — clear state, show login
                        await appstate.loginStatePart.dispatchAction(appstate.logoutAction, null);
                    }
                }
                else {
                    // JWT expired, clear the stored state
                    await appstate.loginStatePart.dispatchAction(appstate.logoutAction, null);
                }
            }
        }
        async login(username, password) {
            const domtools = await this.domtoolsPromise;
            console.log(`Attempting to login...`);
            const simpleLogin = this.shadowRoot.querySelector('dees-simple-login');
            const form = simpleLogin.shadowRoot.querySelector('dees-form');
            form.setStatus('pending', 'Logging in...');
            const state = await appstate.loginStatePart.dispatchAction(appstate.loginAction, {
                username,
                password,
            });
            if (state.identity) {
                console.log('Login successful');
                this.loginState = state;
                form.setStatus('success', 'Logged in!');
                await simpleLogin.switchToSlottedContent();
                await appstate.statsStatePart.dispatchAction(appstate.fetchAllStatsAction, null);
                await appstate.configStatePart.dispatchAction(appstate.fetchConfigurationAction, null);
            }
            else {
                form.setStatus('error', 'Login failed!');
                await domtools.convenience.smartdelay.delayFor(2000);
                form.reset();
            }
        }
        static {
            __runInitializers(_classThis, _classExtraInitializers);
        }
    };
    return OpsDashboard = _classThis;
})();
export { OpsDashboard };
//# sourceMappingURL=data:application/json;base64, 