import {AdjustmentFilter} from '@pixi/filter-adjustment';
import {GlowFilter} from '@pixi/filter-glow';
import {Container} from '@pixi/react';
import {useCallback, useEffect, useState} from 'react';

import {usePacket} from '@/react/context/client.js';
import {useEcs, useEcsTick} from '@/react/context/ecs.js';
import {useMainEntity} from '@/react/context/main-entity.js';
import {useRadians} from '@/react/context/radians.js';

import Entity from './entity.jsx';

export default function Entities({monopolizers, particleWorker}) {
  const [ecs] = useEcs();
  const [entities, setEntities] = useState({});
  const [mainEntity] = useMainEntity();
  const radians = useRadians();
  const [willInteractWith, setWillInteractWith] = useState(0);
  const [interactionFilters] = useState([
    new AdjustmentFilter(),
    new GlowFilter({color: 0x0}),
  ]);
  useEffect(() => {
    if (!ecs || !particleWorker) {
      return;
    }
    async function onMessage(diff) {
      await ecs.apply(diff.data);
      const deleted = {};
      const updated = {};
      for (const id in diff.data) {
        if (!diff.data[id]) {
          deleted[id] = true;
        }
        else {
          updated[id] = ecs.get(id);
        }
      }
      setEntities((entities) => {
        for (const id in deleted) {
          delete entities[id];
        }
        return {
          ...entities,
          ...updated,
        };
      });
    }
    particleWorker.addEventListener('message', onMessage);
    return () => {
      particleWorker.removeEventListener('message', onMessage);
    };
  }, [ecs, particleWorker]);
  const pulse = (Math.cos(radians / 4) + 1) * 0.5;
  interactionFilters[0].brightness = (pulse * 0.75) + 1;
  interactionFilters[1].outerStrength = pulse * 0.5;
  usePacket('EcsChange', async () => {
    setEntities({});
  });
  const onEcsTickEntities = useCallback((payload, ecs) => {
    const deleting = {};
    const updating = {};
    for (const id in payload) {
      if ('1' === id) {
        continue;
      }
      const update = payload[id];
      if (false === update) {
        deleting[id] = true;
        continue;
      }
      updating[id] = ecs.get(id);
    }
    setEntities((entities) => {
      for (const id in deleting) {
        delete entities[id];
      }
      return {
        ...entities,
        ...updating,
      };
    });
  }, []);
  useEcsTick(onEcsTickEntities);
  const onEcsTickParticles = useCallback((payload) => {
    for (const id in payload) {
      const update = payload[id];
      if (update.Emitter?.emit) {
        for (const id in update.Emitter.emit) {
          particleWorker?.postMessage(update.Emitter.emit[id]);
        }
      }
    }
  }, [particleWorker]);
  useEcsTick(onEcsTickParticles);
  const onEcsTickInteractions = useCallback((payload, ecs) => {
    const main = ecs.get(mainEntity);
    if (main) {
      setWillInteractWith(main.Interacts.willInteractWith);
    }
  }, [mainEntity]);
  useEcsTick(onEcsTickInteractions);
  const renderables = [];
  for (const id in entities) {
    const isHighlightedInteraction = 0 === monopolizers.length && id == willInteractWith;
    renderables.push(
      <Entity
        filters={isHighlightedInteraction ? interactionFilters : null}
        entity={entities[id]}
        key={id}
      />
    );
  }
  return (
    <Container
      sortableChildren
    >
      {renderables}
    </Container>
  );
}