const existedObject = {
      id: `"some-id"`,
      '"quote-key"': 2
}

import Writer from 'code-block-writer'
import { match } from 'ts-pattern'

type Wrappers = { [key in string]: { start: string; end: string } }

// eslint-disable-next-line @typescript-eslint/no-explicit-any
export function writeAny(writer: Writer, raw: any, wrappers: Wrappers = {}, needComma = false) {
  match(typeof raw)
    .with('object', () => writeObject(writer, raw, wrappers, true))
    .with('string', () => writer.quote(raw))
    .with('number', () => {
      writer.write(`${raw}`)
    })
    .with('bigint', () => {
      writer.write(`${raw}`)
    })
    .with('boolean', () => {
      writer.write(raw ? 'true' : 'false')
    })
    .with('symbol', () => {
      writer.quote(`${raw}`)
    })
    .otherwise(() => {
      if (raw === null) {
        writer.write('null')
      } else if (raw === undefined) {
        writer.write('undefined')
      }
    })
  if (needComma) {
    writer.write(',')
  }
}

// eslint-disable-next-line @typescript-eslint/ban-types
export const writeObject = (writer: Writer, raw: object, wrappers: Wrappers = {}, needComma: boolean) => {
  if (Array.isArray(raw)) {
    writer.write(JSON.stringify(raw))
  } else {
    writer.write('{')
    Object.keys(raw).forEach((key) => {
      const spec = new RegExp('[^A-Za-z0-9]')
      const hasSpecSymbols = spec.test(key)
      writer.newLineIfLastNot()
      if (hasSpecSymbols) {
        writer.quote(key)
      } else {
        writer.write(key)
      }
      writer.write(`: ${wrappers[key]?.start ? wrappers[key].start : ''}`)
      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
      // @ts-ignore
      writeAny(writer, raw[key], wrappers, needComma)

      if (wrappers[key]?.end) {
        writer.write(wrappers[key].end)
      }
    })
    writer.write('}')
  }
}

sourceFile.addVariableStatement({
    isExported: true,
    declarationKind: VariableDeclarationKind.Const,
    declarations: [
      {
        name: 'flavor',
        initializer: (writer) => {
          return writeAny(writer, someObject, {
          // this will patch values with key 'textStyle' by inserting in start _StyleSheet.create(_ and in the end _),_)
            textStyle: {
              start: 'StyleSheet.create(',
              end: '),',
            },
          })
        },
      },
    ],
  })

const incorrectPropNameChars = [" ", "-", "."];
function sanitizePropName(propName: string) {
    if (incorrectPropNameChars.some(char => propName.includes(char))) {
        return `"${propName}"`;
    }
    return propName;
}

function createProperty(
    name: string,
    type: string,
    doc: string,
    isArray: boolean,
    optional = true
): PropertySignatureStructure {
    return {
        kind: StructureKind.PropertySignature,
        name: sanitizePropName(name),
        docs: [doc],
        hasQuestionToken: true,
        type: isArray ? `Array<${type}>` : type,
    };
}

export function propertyKey(value: string): string | WriterFunction {
  if (/^\w+$/.test(value)) {
    return value;
  }
  // return JSON.stringify(value); // my current workaround
  return (writer) => writer.quote(value);
}

    // Adds quotes if structure is not a valid variable name
    // AND the string is not enclosed in quotation marks
    if (structure.name instanceof Function)
      structure.name(writer)
    else if (isValidVariableName(structure.name) || StringUtils.isQuoted(structure.name))
      writer.write(structure.name);
    else
      writer.quote(structure.name);