import { clientStore, config, datastore, editor, index } from "@silverbulletmd/silverbullet/syscalls";
import { convertIcsCalendar, type IcsCalendar, type IcsEvent, type IcsDateObjects } from "ts-ics";

const VERSION = "0.3.1";
const CACHE_KEY = "icalendar:lastSync";
const DEFAULT_CACHE_DURATION_SECONDS = 21600; // 6 hours

// Mapping of common Windows/Outlook timezones to their standard offsets (in hours)
const TIMEZONE_OFFSETS: Record<string, number> = {
  "GMT Standard Time": 0,
  "W. Europe Standard Time": 1,
  "Central Europe Standard Time": 1,
  "Romance Standard Time": 1,
  "Central European Standard Time": 1,
  "Eastern Standard Time": -5,
  "Central Standard Time": -6,
  "Mountain Standard Time": -7,
  "Pacific Standard Time": -8,
  "UTC": 0,
  "None": 0
};

// ============================================================================
// Types
// ============================================================================

type DateToString<T> = T extends Date ? string
  : T extends IcsDateObjects ? string
  : T extends object ? { [K in keyof T]: DateToString<T[K]> }
  : T extends Array<infer U> ? Array<DateToString<U>>
  : T;

interface Source {
  url: string;
  name: string | undefined;
}

interface PlugConfig {
  sources: any;
  cacheDuration: number | undefined;
  tzShift: number | undefined;
}

interface CalendarEvent extends DateToString<IcsEvent> {
  ref: string;
  tag: "ical-event";
  sourceName: string | undefined;
}

// ============================================================================
// Utility Functions
// ============================================================================

function toLocalISO(d: Date): string {
  const pad = (n: number) => String(n).padStart(2, "0");
  return d.getFullYear() +
    "-" + pad(d.getMonth() + 1) +
    "-" + pad(d.getDate()) +
    "T" + pad(d.getHours()) +
    ":" + pad(d.getMinutes()) +
    ":" + pad(d.getSeconds()) +
    "." + String(d.getMilliseconds()).padStart(3, "0");
}

function processIcsDate(obj: any, manualShift = 0): string {
  if (!obj) return "";
  let wallTimeStr = "";
  if (obj.local && typeof obj.local.date === "string") {
    wallTimeStr = obj.local.date;
  } else if (typeof obj.date === "string") {
    wallTimeStr = obj.date;
  } else if (obj.date instanceof Date) {
    wallTimeStr = obj.date.toISOString();
  } else if (obj instanceof Date) {
    wallTimeStr = obj.toISOString();
  }
    
  if (!wallTimeStr) return "";

  // 1. Extract the "Wall Time" from the string (ignoring Z if present)
  const baseDate = new Date(wallTimeStr.replace("Z", "") + "Z");
  
  // 2. Determine Source Timezone Offset
  const tzName = obj.local?.timezone || obj.timezone || "UTC";
  const sourceOffset = TIMEZONE_OFFSETS[tzName] ?? 0;
  
  // 3. Calculate True UTC: WallTime - SourceOffset
  const utcMillis = baseDate.getTime() - (sourceOffset * 3600000);
  
  // 4. Apply User's Manual Shift and Localize
  return toLocalISO(new Date(utcMillis + (manualShift * 3600000)));
}

function isIcsDateObjects(obj: any): obj is IcsDateObjects {
  return obj && typeof obj === 'object' && ('date' in obj && 'type' in obj);
}

async function sha256Hash(str: string): Promise<string> {
  const encoder = new TextEncoder();
  const data = encoder.encode(str);
  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map(b => b.toString(16).padStart(2, "0")).join("");
}

function convertDatesToStrings<T>(obj: T, hourShift = 0): DateToString<T> {
  if (obj === null || obj === undefined) return obj as DateToString<T>;
  if (isIcsDateObjects(obj)) return processIcsDate(obj, hourShift) as DateToString<T>;
  if (obj instanceof Date) return processIcsDate({ date: obj }, hourShift) as DateToString<T>;
  if (Array.isArray(obj)) return obj.map(item => convertDatesToStrings(item, hourShift)) as DateToString<T>;
  if (typeof obj === 'object') {
    const result: any = {};
    for (const key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        result[key] = convertDatesToStrings((obj as any)[key], hourShift);
      }
    }
    return result as DateToString<T>;
  }
  return obj as DateToString<T>;
}

// ============================================================================
// Configuration & Commands
// ============================================================================

async function getSources(): Promise<{ sources: Source[], tzShift: number }> {
  try {
    const rawConfig = await config.get<PlugConfig>("icalendar", { sources: [] });
    let sources: Source[] = [];
    let tzShift = rawConfig.tzShift ?? 0;

    let rawSources = rawConfig.sources;
    if (rawSources && typeof rawSources === "object") {
      if (rawSources.tzShift !== undefined && tzShift === 0) tzShift = rawSources.tzShift;
      if (Array.isArray(rawSources)) {
        sources = rawSources.filter(s => s && typeof s.url === "string");
      } else if (rawSources.url) {
        sources = [rawSources];
      } else {
        for (const key in rawSources) {
          if (rawSources[key] && typeof rawSources[key].url === "string") sources.push(rawSources[key]);
        }
      }
    }
    return { sources, tzShift };
  } catch (e) {
    console.error("Failed to load configuration", e);
    return { sources: [], tzShift: 0 };
  }
}

async function fetchAndParseCalendar(source: Source, hourShift = 0): Promise<CalendarEvent[]> {
  let url = source.url.trim();
  if (url.includes(" ")) url = encodeURI(url);
  
  const response = await fetch(url, {
    headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" }
  });

  if (!response.ok) throw new Error(`HTTP ${response.status}`);

  const icsData = await response.text();
  const calendar: IcsCalendar = convertIcsCalendar(undefined, icsData);

  if (!calendar.events) return [];

  return await Promise.all(calendar.events.map(async (icsEvent: IcsEvent): Promise<CalendarEvent> => {
    const uniqueKey = `${icsEvent.start?.date || ''}${icsEvent.uid || icsEvent.summary || ''}`;
    const ref = await sha256Hash(uniqueKey);

    return convertDatesToStrings({
      ...icsEvent,
      ref,
      tag: "ical-event" as const,
      sourceName: source.name,
    }, hourShift);
  }));
}

export async function syncCalendars() {
  try {
    const { sources, tzShift } = await getSources();
    if (sources.length === 0) {
        console.log("[iCalendar] No sources configured.");
        return;
    }

    await editor.flashNotification("Syncing calendars...", "info");

    const allEvents: CalendarEvent[] = [];
    for (const source of sources) {
      try {
        const events = await fetchAndParseCalendar(source, tzShift);
        allEvents.push(...events);
      } catch (err) {
        console.error(`[iCalendar] Failed to sync ${source.name}:`, err);
        await editor.flashNotification(`Failed to sync ${source.name}`, "error");
      }
    }

    await index.indexObjects("$icalendar", allEvents);
    await editor.flashNotification(`Synced ${allEvents.length} events`, "info");
  } catch (err) {
    console.error("[iCalendar] Sync failed:", err);
  }
}

export async function forceSync() {
  await clientStore.del(CACHE_KEY);
  await syncCalendars();
}

export async function clearCache() {
  if (!await editor.confirm("Clear all calendar events?")) return;
  const pageKeys = await datastore.query({ prefix: ["ridx", "$icalendar"] });
  const allKeys: any[] = [];
  for (const { key } of pageKeys) {
    allKeys.push(key);
    allKeys.push(["idx", ...key.slice(2), "$icalendar"]);
  }
  if (allKeys.length > 0) await datastore.batchDel(allKeys);
  await clientStore.del(CACHE_KEY);
  await editor.flashNotification("Calendar index cleared", "info");
}

export async function showVersion() {
  await editor.flashNotification(`iCalendar Plug ${VERSION}`, "info");
}