import { Zombie } from './Zombie.js';
import { GameObject } from '../engine/GameObject.js';
import { Vector2D } from '../engine/Vector2D.js';
import { WitchProjectile } from './WitchProjectile.js';

export class Witch extends Zombie {
  constructor(
    x,
    y,
    target,
    {
      container,
      viewport,
      speed = 85,
      size = 28,
      color = [0.55, 0.2, 0.8, 1],
      health = 5,
      knockback = 180,
      scoreValue = 4,
      preferredDistance = 220,
      fireInterval = 2.2,
      projectileSpeed = 220,
      projectileCount = 1,
      projectileSpread = 0.08,
      projectileColor = [0.7, 0.2, 1, 1],
      emergeTime = 0,
      spawnProjectile = (p) => {},
      onDeath = null,
    } = {},
  ) {
    super(x, y, target, {
      container,
      viewport,
      speed,
      size,
      color,
      health,
      knockback,
      scoreValue,
      emergeTime,
      onDeath,
    });
    this.preferredDistance = preferredDistance;
    this.fireInterval = fireInterval;
    this.projectileSpeed = projectileSpeed;
    this.projectileCount = projectileCount;
    this.projectileSpread = projectileSpread;
    this.projectileColor = projectileColor;
    this.spawnProjectile = spawnProjectile;
    this._fireTimer = 0;
    this._time = 0;
    this._cast = 0;
  }

  update(dt) {
    this._time += dt;
    this._cast = Math.max(0, this._cast - dt);

    if (this._updateEmerge(dt)) {
      return;
    }

    this._fireTimer -= dt;

    const delta = this.target.pos.subV(this.pos);
    const distance = delta.length();

    let move = new Vector2D(0, 0);
    if (distance > 1) {
      const dir = delta.divS(distance);
      if (distance < this.preferredDistance) {
        move = dir.mulS(-this.speed);
      } else if (distance > this.preferredDistance + 40) {
        move = dir.mulS(this.speed);
      }
    }

    this.velocity = move.addV(this._hitKnockback);
    GameObject.prototype.update.call(this, dt);

    this._hitKnockback = this._hitKnockback.mulS(Math.max(0, 1 - dt * this.knockbackDamping));
    this._flash = Math.max(0, this._flash - dt);

    if (this._fireTimer <= 0 && this.target.health > 0 && distance < 480) {
      this._fireTimer = this.fireInterval * (0.8 + Math.random() * 0.4);
      this.fire();
    }
  }

  _onEmergenceComplete() {
    this._fireTimer = this.fireInterval * (0.4 + Math.random() * 0.4);
  }

  fire() {
    this._cast = 0.22;
    const aim = this.target.pos.subV(this.pos);
    const aimAngle = aim.lengthSqrt() > 1
      ? Math.atan2(aim.y, aim.x)
      : this._time;

    const offset = ((this.projectileCount - 1) / 2) * this.projectileSpread;
    for (let i = 0; i < this.projectileCount; i += 1) {
      const angle = aimAngle - offset + i * this.projectileSpread;
      const direction = new Vector2D(Math.cos(angle), Math.sin(angle));
      const projectile = new WitchProjectile(this.pos.x, this.pos.y, direction, {
        container: this.container,
        viewport: this.viewport,
        speed: this.projectileSpeed,
        color: this.projectileColor,
      });
      this.spawnProjectile(projectile);
    }
  }

  draw(renderer) {
    this._drawEmerge(renderer);
    let s = this.size * this._emergeSize();

    let bodyColor = this.baseColor;
    if (this._flash > 0) {
      bodyColor = [1, 1, 1, 1];
    } else if (this.maxHealth > 1) {
      const hpRatio = this.health / this.maxHealth;
      bodyColor = [
        this.baseColor[0] + (1 - this.baseColor[0]) * (1 - hpRatio),
        this.baseColor[1] * hpRatio,
        this.baseColor[2] * hpRatio,
        1,
      ];
    }

    const bob = Math.sin(this._time * 3.4) * s * 0.09;
    const sway = Math.sin(this._time * 1.7) * 0.09;
    const castRatio = Math.min(1, this._cast / 0.22);
    const charge = Math.max(
      0,
      Math.min(1, (this.fireInterval - this._fireTimer) / this.fireInterval),
    );
    const targetSide = this.target.pos.x < this.pos.x ? -1 : 1;
    const flightSide = Math.abs(this.velocity.x) > 20
      ? (this.velocity.x < 0 ? -1 : 1)
      : targetSide;
    const facing = flightSide;
    const lean = facing * s * 0.05;

    const drawLimb = (ax, ay, bx, by, thickness, limbColor) => {
      const len = Math.hypot(bx - ax, by - ay);
      if (len < 1) return;
      renderer.drawTexture(
        renderer.whiteTexture,
        (ax + bx) / 2 - len / 2,
        (ay + by) / 2 - thickness / 2,
        len,
        thickness,
        limbColor,
        Math.atan2(by - ay, bx - ax),
      );
    };

    const robe = s * 0.9;
    const robeW = robe * (1 + Math.sin(this._time * 3.4) * 0.05);
    const cy = this.pos.y + bob;
    renderer.drawTexture(
      renderer.whiteTexture,
      this.pos.x + lean - robeW / 2,
      cy - robe / 2,
      robeW,
      robe,
      bodyColor,
    );

    const armColor = [bodyColor[0] * 0.72, bodyColor[1] * 0.72, bodyColor[2] * 0.72, 1];
    const armW = s * 0.16;
    const armLen = s * (0.3 + castRatio * 0.26);
    const armSpread = s * (0.36 + castRatio * 0.14);
    const armY = cy - robe * 0.2 - castRatio * s * 0.14;
    for (let i = 0; i < 2; i += 1) {
      const sign = i === 0 ? 1 : -1;
      const raise = Math.sin(this._time * 6) * castRatio * s * 0.06;
      renderer.drawTexture(
        renderer.whiteTexture,
        this.pos.x + sign * armSpread - armW / 2,
        armY - armLen / 2 + sign * raise,
        armW,
        armLen,
        armColor,
      );
    }

    const hatW = s * 0.7;
    const hatH = s * 0.9;
    const hatCx = this.pos.x + lean + sway * s * 0.14;
    const hatCy = cy - robe / 2 - hatH * 0.55 + bob * 0.4;
    const hatAngle = sway * 0.8 + castRatio * -0.08;
    renderer.drawTexture(
      renderer.whiteTexture,
      hatCx - hatW / 2,
      hatCy - hatH / 2,
      hatW,
      hatH,
      [0.15, 0.08, 0.2, 1],
      hatAngle,
    );

    const brimW = s * 0.98;
    const brimH = s * 0.14;
    renderer.drawTexture(
      renderer.whiteTexture,
      hatCx - brimW / 2,
      hatCy + hatH * 0.1 - brimH / 2,
      brimW,
      brimH,
      [0.15, 0.08, 0.2, 1],
      hatAngle,
    );

    const seatY = cy + robe * 0.14 + Math.sin(this._time * 2.3) * s * 0.02;
    const seatX = this.pos.x + lean;
    const handleX = seatX + facing * s * 0.5;
    const bristleX = seatX - facing * s * 0.24;
    drawLimb(handleX, seatY, bristleX, seatY, s * 0.13, [0.4, 0.3, 0.15, 1]);
    drawLimb(bristleX, seatY - s * 0.02, bristleX - facing * s * 0.14, seatY - s * 0.09, s * 0.18, [0.62, 0.48, 0.24, 1]);

    if (charge > 0.25) {
      const eyeFade = (charge - 0.25) / 0.75;
      const eyeY = hatCy + hatH * 0.32;
      const eyeSpread = s * 0.13;
      const eyeS = s * 0.11;
      const eyeCx = this.pos.x + lean + targetSide * s * 0.06;
      renderer.setBlendMode('additive');
      renderer.drawTexture(
        renderer.glowTexture,
        eyeCx - eyeSpread - eyeS,
        eyeY - eyeS,
        eyeS * 2,
        eyeS * 2,
        [0.85, 0.35, 1, 0.75 * eyeFade],
      );
      renderer.drawTexture(
        renderer.glowTexture,
        eyeCx + eyeSpread - eyeS,
        eyeY - eyeS,
        eyeS * 2,
        eyeS * 2,
        [0.85, 0.35, 1, 0.75 * eyeFade],
      );
      renderer.setBlendMode('normal');
    }

    if (castRatio > 0) {
      renderer.setBlendMode('additive');
      const fx = this.pos.x;
      const fy = hatCy - hatH * 0.72;
      renderer.drawTexture(
        renderer.glowTexture,
        fx - s * 0.5,
        fy - s * 0.5,
        s,
        s,
        [0.8, 0.4, 1, 0.9 * castRatio],
      );
      renderer.setBlendMode('normal');
    }
  }
}