import {
	managedVariations,
} from '../../data'

import type {
	BlockVariationSlug,
	Variation,
	Variations,
	VariationSlug,
} from '.'

import type {
	tBlock,
	tBlockVariation,
	tVariationInnerBlock,
} from '@ska/shared'

/**
 * Managed variation cannot be deleted, but can be reset to default.
 */
export const isManagedVariation = (slug: VariationSlug) => {
	return Object(managedVariations).hasOwnProperty(slug)
}

export const resolveVariationSlug = (slug: BlockVariationSlug, variations: Variations): VariationSlug | undefined => {

	if(!slug) {
		return undefined
	}

	if(Object(variations).hasOwnProperty(slug)) {
		return slug as VariationSlug
	}

	/** Back-compat. */
	if(Number.isInteger(slug)) {

		const found = Object.entries(variations).map(([slug, preset]) => ({slug, ...preset})).find(({__id}) => {
			return __id === slug
		})

		if(found) {
			return found.slug
		}
	}

	return slug as VariationSlug
}

export const resolveVariation = (slug: BlockVariationSlug, variations: Variations): Variation => {

	const resolvedSlug = resolveVariationSlug(slug, variations)

	if(resolvedSlug && Object(variations).hasOwnProperty(resolvedSlug)) {
		return variations[resolvedSlug]
	}

	return {
		ref: '404',
		title: 'Not found',
		description: 'Variation not found.',
		block: 'ska/element',
		variation: '{}',
	}
}

export const flattenInnerBlocks = (innerBlocks: any[]) => {

	const result: any[] = []

	const stack = [...innerBlocks]
	while(stack.length) {

		const {
			innerBlocks = [],
			...block
		} = stack.shift()

		stack.push(...innerBlocks)
		result.push(block)
	}

	return result
}

export interface CreateVariationArgs {
	includeContent: boolean
}

export const createVariationInnerBlocks = ({name, attributes = {}, innerBlocks = []}: tBlock, args: CreateVariationArgs): tVariationInnerBlock => {

	const {
		includeContent = false,
	} = args

	const {
		content,
		...restAttributes
	} = attributes

	return {
		name,
		attributes: {
			...restAttributes,
			...(includeContent && {
				content,
			}),
		},
		...(innerBlocks.length > 0 && {
			innerBlocks: innerBlocks.map(innerBlock => createVariationInnerBlocks(innerBlock, args)),
		}),
	}
}

export const createVariation = (block: tBlock, args: CreateVariationArgs): tBlockVariation => {

	const {
		includeContent = false,
	} = args

	const {
		attributes: blockAttributes = {},
		innerBlocks = [],
	} = block

	const {
		content,
		...attributes
	} = blockAttributes

	return {
		attributes: {
			...attributes,
			...(includeContent && {
				content,
			}),
		},
		...(innerBlocks.length > 0 && {
			innerBlocks: innerBlocks.map(innerBlock => createVariationInnerBlocks(innerBlock, args)),
		}),
	}
}