import { describe, it, expect } from 'vitest';
import {
  resolveLayerVisibility,
  isLayerVisible,
  layerById,
  effectiveOpacity,
  effectiveZIndex,
  type MapDataLayer,
} from './map-layers-model';

const layers: MapDataLayer[] = [
  { id: 'alvos', label: 'Alvos', visible: true, opacity: 0.5, zIndex: 20 },
  { id: 'setores', label: 'Setores', visible: false },
  { id: 'rotas', label: 'Rotas' },
];

describe('resolveLayerVisibility', () => {
  it('treats an omitted visible flag as visible', () => {
    expect(resolveLayerVisibility(layers)).toEqual({
      alvos: true,
      setores: false,
      rotas: true,
    });
  });

  it('handles no layers at all', () => {
    expect(resolveLayerVisibility(undefined)).toEqual({});
  });
});

describe('isLayerVisible', () => {
  const visibility = resolveLayerVisibility(layers);

  it('always shows features with no layer', () => {
    expect(isLayerVisible(undefined, visibility)).toBe(true);
  });

  it('respects a hidden layer', () => {
    expect(isLayerVisible('setores', visibility)).toBe(false);
  });

  it('shows features pointing at an unknown layer', () => {
    // A typo must not silently swallow data.
    expect(isLayerVisible('inexistente', visibility)).toBe(true);
  });
});

describe('layerById', () => {
  it('finds a layer', () => {
    expect(layerById('alvos', layers)?.label).toBe('Alvos');
  });

  it('returns undefined for unknown or missing ids', () => {
    expect(layerById('nope', layers)).toBeUndefined();
    expect(layerById(undefined, layers)).toBeUndefined();
    expect(layerById('alvos', undefined)).toBeUndefined();
  });
});

describe('effectiveOpacity', () => {
  it('multiplies feature opacity by its layer', () => {
    expect(effectiveOpacity(0.5, layers[0])).toBeCloseTo(0.25, 5);
  });

  it('defaults both sides to fully opaque', () => {
    expect(effectiveOpacity(undefined, undefined)).toBe(1);
    expect(effectiveOpacity(undefined, layers[0])).toBe(0.5);
    expect(effectiveOpacity(0.4, layers[2])).toBeCloseTo(0.4, 5);
  });

  it('clamps out-of-range values', () => {
    expect(effectiveOpacity(5, undefined)).toBe(1);
    expect(effectiveOpacity(-1, undefined)).toBe(0);
  });
});

describe('effectiveZIndex', () => {
  it('prefers the feature value', () => {
    expect(effectiveZIndex(99, layers[0])).toBe(99);
  });

  it('falls back to the layer', () => {
    expect(effectiveZIndex(undefined, layers[0])).toBe(20);
  });

  it('is undefined when neither declares one', () => {
    expect(effectiveZIndex(undefined, layers[2])).toBeUndefined();
  });
});