/**
 * Base adapter utilities and factory
 */

import type { SecureStorageAdapter, SecureStorageOptions, StorageResult } from "./types";

/**
 * Create a namespaced key
 */
export function namespacedKey(namespace: string | undefined, key: string): string {
  const prefix = namespace ? `${namespace}:` : "styx:";
  return `${prefix}${key}`;
}

/**
 * Create a success result
 */
export function ok<T>(value: T): StorageResult<T> {
  return { ok: true, value };
}

/**
 * Create an error result
 */
export function err<T>(error: string): StorageResult<T> {
  return { ok: false, error };
}

/**
 * Wrap an async operation with error handling
 */
export async function wrap<T>(
  fn: () => Promise<T>,
  errorPrefix: string
): Promise<StorageResult<T>> {
  try {
    const value = await fn();
    return ok(value);
  } catch (e) {
    const msg = e instanceof Error ? e.message : String(e);
    return err(`${errorPrefix}: ${msg}`);
  }
}

/**
 * Abstract base class for secure storage adapters
 */
export abstract class BaseSecureStorageAdapter implements SecureStorageAdapter {
  abstract readonly name: string;
  abstract readonly available: boolean;
  
  protected readonly namespace: string;
  protected readonly options: SecureStorageOptions;
  
  constructor(options: SecureStorageOptions = {}) {
    this.namespace = options.namespace ?? "styx";
    this.options = options;
  }
  
  protected key(rawKey: string): string {
    return namespacedKey(this.namespace, rawKey);
  }
  
  abstract set(key: string, value: string): Promise<StorageResult<void>>;
  abstract get(key: string): Promise<StorageResult<string | null>>;
  abstract delete(key: string): Promise<StorageResult<void>>;
  abstract has(key: string): Promise<StorageResult<boolean>>;
}