import type { PostImportOrigin,
	      PostImportExistingPost,
	      PostImportResetSnapshot,
	      PostImportRow,
	      PostImportSession,
	      PostImportStatus,
	      PostImportSkipReason,
	      StorageErrorHandler } from '@/lib/postImportTypes'

const SESSION_VERSION = 3
const SESSION_PREFIX = 'post-import-session:'
const SOURCE_DRAFT_KEY = 'post-import-source-draft'
const SESSION_MAX_AGE_MS = 24 * 60 * 60 * 1000
const MAX_SESSION_JSON_BYTES = 262_144
const MAX_SESSION_ROWS = 100
const MAX_SOURCE_BYTES = 262_144
const SESSION_ID_PATTERN =
    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
const ATTRIBUTE_KEYS = [
    'title',
    'thumbnailBase',
    'originalCreatedFrom',
    'originalCreatedBefore',
    'duration',
    'videoMs',
    'tags',
    'parentPostIds'] as const
const PROVENANCE_KEYS = [...ATTRIBUTE_KEYS, 'url'] as const
const TAG_SOURCE_KEYS = ['automatic', 'manual'] as const
const WARNING_KEYS = [...ATTRIBUTE_KEYS, 'url'] as const
const ROW_KEYS = [
    'sourceRow',
    'url',
    'attributes',
    'fieldWarnings',
    'baseWarnings',
    'validationErrors',
    'importErrors',
    'provenance',
    'tagSources',
    'status',
    'skipReason',
    'existingPostId',
    'existingPost',
    'metadataUrl',
    'resetSnapshot',
    'createdPostId',
    'importStatus',
    'recoverable'] as const
const SESSION_KEYS = [
    'version',
    'expiresAt',
    'source',
    'rows',
    'repairMode'] as const
const textEncoder = new TextEncoder ()


const isPlainObject = (value: unknown): value is Record<string, unknown> =>
    typeof value === 'object' && value != null && !(Array.isArray (value))

const byteLength = (value: string): number =>
    textEncoder.encode (value).byteLength


export const validatePostImportSessionId = (value: unknown): string | null => {
    if (typeof value !== 'string')
      return null
    if (value.length > 36 || !(SESSION_ID_PATTERN.test (value)))
      return null

    return value.toLowerCase ()
}


export const generatePostImportSessionId = (): string =>
    crypto.randomUUID ()


const sessionKey = (sessionId: string): string => `${ SESSION_PREFIX }${ sessionId }`


const readStorage = (
    key:       string,
    onError?:  StorageErrorHandler,
): string | null => {
    if (typeof window === 'undefined')
      return null

    try
    {
      return sessionStorage.getItem (key)
    }
    catch
    {
      onError?.('保存済みデータを読み込めませんでした．')
      return null
    }
}


const writeStorage = (
    key:       string,
    value:     string,
    onError?:  StorageErrorHandler,
): boolean => {
    if (typeof window === 'undefined')
      return false

    try
    {
      sessionStorage.setItem (key, value)
      return true
    }
    catch
    {
      onError?.('ブラウザへ保存できませんでした．')
      return false
    }
}


const removeStorage = (
    key:       string,
    onError?:  StorageErrorHandler,
) => {
    if (typeof window === 'undefined')
      return

    try
    {
      sessionStorage.removeItem (key)
    }
    catch
    {
      onError?.('保存済みデータを削除できませんでした．')
    }
}


const ensureStringListRecord = (value: unknown): Record<string, string[]> | null => {
    if (!(isPlainObject (value)))
      return null

    const result: Record<string, string[]> = { }
    for (const [key, entry] of Object.entries (value))
      {
        if (!(Array.isArray (entry)) || !(entry.every (item => typeof item === 'string')))
          return null
        result[key] = entry
      }
    return result
}


const isValidStatus = (
    value: unknown,
): value is PostImportRow['status'] =>
    value === 'ready' || value === 'warning' || value === 'error'


const isValidImportStatus = (
    value: unknown,
): value is PostImportStatus =>
    value === 'pending'
    || value === 'created'
    || value === 'skipped'
    || value === 'failed'


const isValidOrigin = (
    value: unknown,
): value is PostImportOrigin =>
    value === 'automatic' || value === 'manual'


const isValidSkipReason = (
    value: unknown,
): value is PostImportSkipReason =>
    value === 'existing' || value === 'manual'

const isPositiveInteger = (value: unknown): value is number =>
    Number.isInteger (value) && Number (value) > 0

const hasOnlyKeys = (
    value:        Record<string, unknown>,
    allowedKeys:  readonly string[],
): boolean =>
    Object.keys (value).every (key => allowedKeys.includes (key))

const sanitiseResetSnapshot = (value: unknown): PostImportResetSnapshot | null => {
    if (!(isPlainObject (value)))
      return null
    if (!(hasOnlyKeys (value, ['url',
			       'attributes',
			       'provenance',
			       'tagSources',
			       'fieldWarnings',
			       'baseWarnings',
			       'metadataUrl'])))
      return null
    if (typeof value.url !== 'string')
      return null
    if (!(isPlainObject (value.attributes)))
      return null
    if (!(hasOnlyKeys (value.attributes, ATTRIBUTE_KEYS)))
      return null
    if (!(Object.values (value.attributes).every (entry =>
        typeof entry === 'string' || typeof entry === 'number')))
      return null
    if (!(isPlainObject (value.provenance)))
      return null
    if (!(hasOnlyKeys (value.provenance, PROVENANCE_KEYS)))
      return null
    if (!(Object.values (value.provenance).every (origin => isValidOrigin (origin))))
      return null
    if (!(isPlainObject (value.tagSources)))
      return null
    if (!(hasOnlyKeys (value.tagSources, TAG_SOURCE_KEYS)))
      return null
    if (!(Object.values (value.tagSources).every (entry => typeof entry === 'string')))
      return null
    const fieldWarnings = ensureStringListRecord (value.fieldWarnings)
    if (fieldWarnings == null)
      return null
    if (!(hasOnlyKeys (fieldWarnings, WARNING_KEYS)))
      return null
    if (!(Array.isArray (value.baseWarnings))
        || !(value.baseWarnings.every (warning => typeof warning === 'string')))
      return null
    if (value.metadataUrl != null && typeof value.metadataUrl !== 'string')
      return null

    return {
        url: value.url,
        attributes: value.attributes as Record<string, string | number>,
        provenance: value.provenance as Record<string, PostImportOrigin>,
        tagSources: value.tagSources as Record<PostImportOrigin, string>,
        fieldWarnings,
        baseWarnings: value.baseWarnings,
        metadataUrl: value.metadataUrl as string | undefined }
}

const sanitiseExistingPost = (value: unknown): PostImportExistingPost | undefined => {
    if (value == null)
      return undefined
    if (!(isPlainObject (value)))
      return undefined
    if (!(isPositiveInteger (value.id)))
      return undefined
    if (typeof value.title !== 'string' || typeof value.url !== 'string')
      return undefined
    if (value.thumbnailUrl != null && typeof value.thumbnailUrl !== 'string')
      return undefined

    return {
        id: Number (value.id),
        title: value.title,
        url: value.url,
        thumbnailUrl: value.thumbnailUrl as string | undefined }
}

const recalculateThumbnailWarning = (row: PostImportRow): PostImportRow => {
    const others = (row.fieldWarnings.thumbnailBase ?? []).filter (
	key => key !== 'サムネールなし')
    const thumbnailBasePresent =
	typeof row.attributes.thumbnailBase === 'string'
	&& row.attributes.thumbnailBase.trim () !== ''

    return {
        ...row,
        fieldWarnings: {
	    ...row.fieldWarnings,
	    thumbnailBase:
		thumbnailBasePresent
		? others
		: [...new Set ([...others, 'サムネールなし'])] } }
}

const serialiseExistingPost = (value: PostImportExistingPost | undefined) =>
    value == null
    ? undefined
    : {
	 id: value.id,
	 title: value.title,
	 url: value.url,
	 thumbnailUrl: value.thumbnailUrl }

const serialiseResetSnapshot = (value: PostImportResetSnapshot) => ({
    url: value.url,
    attributes: Object.fromEntries (
	Object.entries (value.attributes).map (([key, entry]) => [key, entry])),
    provenance: Object.fromEntries (
	Object.entries (value.provenance).map (([key, entry]) => [key, entry])),
    tagSources: {
	automatic: value.tagSources.automatic,
	manual: value.tagSources.manual },
    fieldWarnings: Object.fromEntries (
	Object.entries (value.fieldWarnings).map (([key, entry]) => [key, [...entry]])),
    baseWarnings: [...value.baseWarnings],
    metadataUrl: value.metadataUrl })

export const serialisePostImportRow = (row: PostImportRow) => {
    const thumbnailBaseWarnings = (() => {
      const others = (row.fieldWarnings.thumbnailBase ?? []).filter (
	  message => message !== 'サムネールなし')
      const thumbnailBasePresent =
	  typeof row.attributes.thumbnailBase === 'string'
	  && row.attributes.thumbnailBase.trim () !== ''
      return thumbnailBasePresent
	  ? others
	  : [...new Set ([...others, 'サムネールなし'])]
    }) ()

    return {
	sourceRow: row.sourceRow,
	url: row.url,
	attributes: Object.fromEntries (
	    Object.entries (row.attributes).map (([key, entry]) => [key, entry])),
	fieldWarnings: Object.fromEntries (
	    Object.entries ({
		...row.fieldWarnings,
		thumbnailBase: thumbnailBaseWarnings }).map (([key, entry]) => [key, [...entry]])),
	baseWarnings: [...row.baseWarnings],
	validationErrors: Object.fromEntries (
	    Object.entries (row.validationErrors).map (([key, entry]) => [key, [...entry]])),
	importErrors:
	    row.importErrors == null
	    ? undefined
	    : Object.fromEntries (
		Object.entries (row.importErrors).map (([key, entry]) => [key, [...entry]])),
	provenance: Object.fromEntries (
	    Object.entries (row.provenance).map (([key, entry]) => [key, entry])),
	tagSources:
	    row.tagSources == null
	    ? undefined
	    : {
		automatic: row.tagSources.automatic,
		manual: row.tagSources.manual },
	status: row.status,
	skipReason: row.skipReason,
	existingPostId: row.existingPostId,
	existingPost: serialiseExistingPost (row.existingPost),
	metadataUrl: row.metadataUrl,
	resetSnapshot: serialiseResetSnapshot (row.resetSnapshot),
	createdPostId: row.createdPostId,
	importStatus: row.importStatus,
	recoverable: row.recoverable }
}

export const serialisePostImportRows = (rows: PostImportRow[]) =>
    rows.map (row => serialisePostImportRow (row))

export const serialisedPostImportRowsEqual = (
    left:  PostImportRow[],
    right: PostImportRow[],
): boolean =>
    JSON.stringify (serialisePostImportRows (left))
    === JSON.stringify (serialisePostImportRows (right))


const sanitiseRow = (value: unknown): PostImportRow | null => {
    if (!(isPlainObject (value)))
      return null
    if (!(hasOnlyKeys (value, ROW_KEYS)))
      return null
    if (!(Number.isInteger (value.sourceRow)) || Number (value.sourceRow) <= 0)
      return null
    if (typeof value.url !== 'string')
      return null
    if (byteLength (value.url) > 20_480)
      return null
    if (!(isPlainObject (value.attributes)))
      return null
    if (!(isPlainObject (value.provenance)))
      return null
    if (!(isValidStatus (value.status)))
      return null
    if (value.importStatus != null && !(isValidImportStatus (value.importStatus)))
      return null
    if (value.skipReason != null && !(isValidSkipReason (value.skipReason)))
      return null
    if (value.recoverable != null && value.recoverable !== true)
      return null
    if (value.skipReason === 'existing' && !(isPositiveInteger (value.existingPostId)))
      return null
    if (value.skipReason !== 'existing' && value.existingPostId != null)
      return null
    if (value.importStatus === 'created' && !(isPositiveInteger (value.createdPostId)))
      return null
    if (value.importStatus !== 'created' && value.createdPostId != null)
      return null
    if (value.recoverable === true
        && value.importStatus !== 'failed'
        && value.importStatus !== 'pending')
      return null
    if ((value.importStatus === 'created' || value.importStatus === 'skipped')
        && value.recoverable != null)
      return null

    const validationErrors = ensureStringListRecord (value.validationErrors)
    const fieldWarnings = ensureStringListRecord (value.fieldWarnings)
    const resetSnapshot = sanitiseResetSnapshot (value.resetSnapshot)
    if (validationErrors == null || fieldWarnings == null)
      return null
    if (resetSnapshot == null)
      return null

    const importErrors =
        value.importErrors == null
        ? undefined
        : ensureStringListRecord (value.importErrors)
    if (importErrors === null)
      return null
    if (!(Array.isArray (value.baseWarnings))
        || !(value.baseWarnings.every (warning => typeof warning === 'string')))
      return null

    const provenanceEntries = Object.entries (value.provenance)
    if (!(hasOnlyKeys (value.attributes, ATTRIBUTE_KEYS)))
      return null
    if (!(Object.values (value.attributes).every (entry =>
        typeof entry === 'string' || typeof entry === 'number')))
      return null
    if (!(hasOnlyKeys (value.provenance, PROVENANCE_KEYS)))
      return null
    if (!(provenanceEntries.every (([, origin]) => isValidOrigin (origin))))
      return null

    if (value.tagSources != null)
      {
        if (!(isPlainObject (value.tagSources)))
          return null
        if (!(hasOnlyKeys (value.tagSources, TAG_SOURCE_KEYS)))
          return null
        if (!(Object.values (value.tagSources).every (entry => typeof entry === 'string')))
          return null
      }

    return {
        sourceRow: Number (value.sourceRow),
        url: value.url,
        attributes: value.attributes as Record<string, string | number>,
        fieldWarnings,
        baseWarnings: value.baseWarnings,
        validationErrors,
        importErrors,
        provenance: value.provenance as Record<string, PostImportOrigin>,
        tagSources: value.tagSources as Record<PostImportOrigin, string> | undefined,
        status: value.status,
        skipReason: value.skipReason ?? undefined,
        existingPostId:
            isPositiveInteger (value.existingPostId) ? Number (value.existingPostId) : undefined,
        existingPost: sanitiseExistingPost (value.existingPost),
        metadataUrl: typeof value.metadataUrl === 'string' ? value.metadataUrl : undefined,
        resetSnapshot,
        createdPostId:
            isPositiveInteger (value.createdPostId) ? Number (value.createdPostId) : undefined,
        importStatus: value.importStatus ?? undefined,
        recoverable: value.recoverable === true ? true : undefined }
}

const sanitiseSession = (value: unknown): PostImportSession | null => {
    if (!(isPlainObject (value)))
      return null
    if (!(hasOnlyKeys (value, SESSION_KEYS)))
      return null
    if (value.version !== SESSION_VERSION || !(Array.isArray (value.rows)))
      return null
    if (value.rows.length === 0 || value.rows.length > MAX_SESSION_ROWS)
      return null
    if (typeof value.expiresAt !== 'string' || isExpiredSession (value.expiresAt))
      return null
    if (typeof value.source !== 'string' || byteLength (value.source) > MAX_SOURCE_BYTES)
      return null

    const rows = value.rows.map (sanitiseRow)
    if (rows.some (row => row == null))
      return null
    if ((new Set (rows.map (row => row?.sourceRow))).size !== rows.length)
      return null

    return {
        version: SESSION_VERSION,
        expiresAt: value.expiresAt,
        source: value.source,
        rows: (rows as PostImportRow[]).map (row => recalculateThumbnailWarning (row)),
        repairMode: value.repairMode === 'failed' ? 'failed' : 'all' }
}


const isExpiredSession = (expiresAt: string): boolean => {
    const value = Date.parse (expiresAt)
    return Number.isNaN (value) || value <= Date.now ()
}


export const cleanupExpiredPostImportSessions = (
    onError?: StorageErrorHandler,
) => {
    if (typeof window === 'undefined')
      return

    try
    {
      for (let i = 0; i < sessionStorage.length; ++i)
        {
          const key = sessionStorage.key (i)
          if (key == null || !(key.startsWith (SESSION_PREFIX)))
            continue

          const sessionId = validatePostImportSessionId (key.slice (SESSION_PREFIX.length))
          if (sessionId == null)
            {
              sessionStorage.removeItem (key)
              --i
              continue
            }

          const raw = sessionStorage.getItem (key)
          if (raw == null)
            continue
          if (byteLength (raw) > MAX_SESSION_JSON_BYTES)
            {
              sessionStorage.removeItem (key)
              --i
              continue
            }

          try
          {
            if (sanitiseSession (JSON.parse (raw)) == null)
              {
                sessionStorage.removeItem (key)
                --i
              }
          }
          catch
          {
            sessionStorage.removeItem (key)
            --i
          }
        }
    }
    catch
    {
      onError?.('保存済みデータを整理できませんでした．')
    }
}


export const loadPostImportSourceDraft = (
    onError?: StorageErrorHandler,
): { source: string } => {
    const raw = readStorage (SOURCE_DRAFT_KEY, onError)
    if (raw == null)
      return { source: '' }

    try
    {
      const value = JSON.parse (raw) as { source?: string }
      return { source: typeof value.source === 'string' ? value.source : '' }
    }
    catch
    {
      return { source: '' }
    }
}


export const savePostImportSourceDraft = (
    source:    string,
    onError?:  StorageErrorHandler,
): boolean =>
    writeStorage (SOURCE_DRAFT_KEY, JSON.stringify ({ source }), onError)


export const clearPostImportSourceDraft = (
    onError?: StorageErrorHandler,
) => {
    removeStorage (SOURCE_DRAFT_KEY, onError)
}


export const savePostImportSession = (
    sessionId: string,
    session: Omit<PostImportSession, 'version' | 'expiresAt'>,
    onError?:  StorageErrorHandler,
): boolean => {
    const validatedId = validatePostImportSessionId (sessionId)
    if (validatedId == null)
      return false

    return writeStorage (
        sessionKey (validatedId),
        JSON.stringify ({
            source: session.source,
            rows: serialisePostImportRows (session.rows),
            repairMode: session.repairMode,
            version: SESSION_VERSION,
            expiresAt: new Date (Date.now () + SESSION_MAX_AGE_MS).toISOString () }),
        onError)
}


export const loadPostImportSession = (
    sessionId: string,
    onError?: StorageErrorHandler,
): PostImportSession | null => {
    const validatedId = validatePostImportSessionId (sessionId)
    if (validatedId == null)
      return null

    const raw = readStorage (sessionKey (validatedId), onError)
    if (raw == null)
      return null
    if (byteLength (raw) > MAX_SESSION_JSON_BYTES)
      {
        removeStorage (sessionKey (validatedId), onError)
        return null
      }

    try
    {
      const session = sanitiseSession (JSON.parse (raw))
      if (session == null)
        {
          removeStorage (sessionKey (validatedId), onError)
          return null
        }
      return session
    }
    catch
    {
      removeStorage (sessionKey (validatedId), onError)
      return null
    }
}


export const clearPostImportSession = (
    sessionId: string,
    onError?: StorageErrorHandler,
) => {
    const validatedId = validatePostImportSessionId (sessionId)
    if (validatedId == null)
      return

    removeStorage (sessionKey (validatedId), onError)
}