---

import {
  ChartSeriesType,
  Intervals,
  IntervalsToTimeframe,
  SymbolInfo,
  SymbolInfoInput,
  TimeFormat,
} from '@src/types';
import { Timeframes } from '@src/types/timeframes';
import { DateFormat, normalizeSymbolInfo } from '@src/utils';

export interface ChartSettings {
  symbolInfo: SymbolInfo;
  timeframe: Timeframes;
  seriesSelected: ChartSeriesType;
  timeFormat: TimeFormat;
  dateFormat: DateFormat;
  interval: Intervals | null;
}

export type ChartSettingsSourceObject = Omit<Partial<ChartSettings>, 'symbolInfo'> & {
  symbolInfo?: SymbolInfoInput;
};

export type ChartSettingsSource = ChartSettingsSourceObject | string;

function parseJsonIfString(value: unknown): unknown {
  if (typeof value !== 'string') {
    return value;
  }

  try {
    return JSON.parse(value);
  } catch {
    return undefined;
  }
}

function asPlainObject(value: unknown): Record<string, unknown> | undefined {
  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
    return undefined;
  }

  return value as Record<string, unknown>;
}

function asString(value: unknown): string | undefined {
  return typeof value === 'string' ? value : undefined;
}

function asSymbolInfo(value: unknown): SymbolInfo | undefined {
  const symbolInfoObject = asPlainObject(value);

  if (!symbolInfoObject) {
    return undefined;
  }

  const symbolId = asString(symbolInfoObject.symbolId);

  if (symbolId === undefined) {
    return undefined;
  }

  return normalizeSymbolInfo({
    symbolId,
    symbol: asString(symbolInfoObject.symbol),
    symbolName: asString(symbolInfoObject.symbolName),
  });
}

function asInterval(value: unknown): Intervals | null | undefined {
  if (value === null) {
    return null;
  }

  const intervalString = asString(value);

  if (intervalString === undefined) {
    return undefined;
  }

  return intervalString in IntervalsToTimeframe ? (intervalString as Intervals) : undefined;
}

export function parseChartSettings(value: unknown): Partial<ChartSettings> {
  const parsedValue = parseJsonIfString(value);
  const settingsObject = asPlainObject(parsedValue);

  if (!settingsObject) {
    return {};
  }

  return {
    symbolInfo: asSymbolInfo(settingsObject.symbolInfo),
    timeframe: asString(settingsObject.timeframe) as Timeframes | undefined,
    seriesSelected: asString(settingsObject.seriesSelected) as ChartSeriesType | undefined,
    timeFormat: asString(settingsObject.timeFormat) as TimeFormat | undefined,
    dateFormat: asString(settingsObject.dateFormat) as DateFormat | undefined,
    interval: asInterval(settingsObject.interval),
  };
}