import { describe, expect, it } from 'vitest';
import {
  CreateAssetCommand,
  SetAssetPropertyCommand,
  SetMachineScopeCommand,
} from '../../src/core/commands/assetCommands';
import { SetOverrideCommand } from '../../src/core/commands/sceneObjectCommands';
import { AddVariableCommand } from '../../src/core/commands/variableCommands';
import { deserializeProject, serializeProject } from '../../src/core/store/serialize';
import { makeBehavior, makeSpriteScene, place, roundTrip } from '../helpers';

describe('serialize', () => {
  it('round-trips a project', () => {
    const f = makeSpriteScene();
    const box = place(f, f.spriteId, { x: 7, y: 8 });
    f.stack.execute(new SetOverrideCommand(f.sceneId, box, 'width', 33));
    expect(roundTrip(f.project)).toEqual(f.project);
  });

  /** A behavior's own rows are not the common ones: coercing against those alone dropped the value. */
  it('keeps a behavior running in the editor across a save', () => {
    const f = makeSpriteScene();
    const behavior = makeBehavior(f, 'B');
    f.stack.execute(new SetAssetPropertyCommand(behavior.id, 'runInEditor', true));
    const loaded = roundTrip(f.project).assets.find((a) => a.id === behavior.id)!;
    expect(loaded.props.runInEditor).toBe(true);
  });

  /** The declarations of a Variables asset and their starting values are the whole asset. */
  it('round-trips a Variables asset and the scope of a state machine', () => {
    const f = makeSpriteScene();
    const shared = new CreateAssetCommand('variables', 'Score');
    f.stack.execute(shared);
    f.stack.execute(new AddVariableCommand(shared.asset.id, 'score', 'number'));
    f.stack.execute(new SetAssetPropertyCommand(shared.asset.id, 'score', 7));
    const machine = new CreateAssetCommand('statemachine', 'M');
    f.stack.execute(machine);
    f.stack.execute(new SetMachineScopeCommand(machine.asset.id, 'global'));
    expect(roundTrip(f.project)).toEqual(f.project);
  });

  /** `local` is the absence of the field, so a project made before scopes existed saves back byte-alike. */
  it('writes no scope for a local machine and reads an unknown one as local', () => {
    const f = makeSpriteScene();
    makeBehavior(f, 'B', ['score']);
    f.stack.execute(new CreateAssetCommand('statemachine', 'M'));
    expect(JSON.stringify(serializeProject(f.project))).not.toContain('scope');

    const loaded = deserializeProject({
      assets: [{ id: 'm1', type: 'statemachine', name: 'M', scope: 'planet' }],
    });
    const machine = loaded.assets[0]!;
    if (machine.type !== 'statemachine') throw new Error('wrong types');
    expect(machine.scope).toBeUndefined();
  });

  it('repairs broken documents', () => {
    const project = deserializeProject(
      {
        name: 'Broken',
        activeSceneId: 'missing',
        assets: [
          {
            id: 's1',
            type: 'scene',
            name: 'Scene',
            props: { backgroundColor: '#000000', junk: 1 },
            objects: [
              {
                id: 'o1',
                assetId: 'sp1',
                position: { x: '5', y: null },
                overrides: { color: '#00ff00', width: -3, foo: 1 },
              },
              { id: 'o2', assetId: 'nope', position: {} },
              { id: 'o3', assetId: 's1', position: {} },
            ],
          },
          { id: 'sp1', type: 'sprite', props: { width: 10 } },
          // An asset type this build does not know (a newer document, a renamed type). It used to
          // be `sound`, which this build does know since #45 – hence a type nothing has claimed.
          { id: 'x', type: 'video' },
          { type: 'camera' },
        ],
      },
      'fallback-id',
    );
    expect(project.id).toBe('fallback-id');
    expect(project.activeSceneId).toBe('s1');
    expect(project.assets.map((a) => a.id)).toEqual(['s1', 'sp1']);
    const scene = project.assets[0]!;
    expect(scene.type === 'scene' && scene.props).toEqual({ backgroundColor: 0 });
    const objects = scene.type === 'scene' ? scene.objects : [];
    expect(objects).toHaveLength(1);
    expect(objects[0]).toEqual({
      id: 'o1',
      assetId: 'sp1',
      name: '',
      position: { x: 5, y: 0, z: 0 },
      editorOffset: { x: 0, y: 0 },
      overrides: { color: 0x00ff00, width: 1 },
      parentId: '',
      instanceEdits: {},
    });
    expect(project.assets[1]!.name).toBe('sprite');
    expect(project.assets[1]!.props).toEqual({
      enabled: true,
      scale: 1,
      rotation: 0,
      mirrorX: false,
      mirrorY: false,
      width: 10,
      height: 100,
      color: 0xffffff,
      texture: '',
      shader: '',
    });
  });
});