import type { State } from "./device"

export default interface Assignment {
  id: string
  deviceIds: string[]
  effect: Effect
  variables: Record<string, number>
}

export interface AssignmentInput {
  match: string
  effect: Effect
}

export type Effect = 
  | { manual: State }
  | { solid: { states: State[], animationMs: number, interleave: number } }
  | { gradient: { states: State[], animationMs: number, reverse: boolean, interpolate: boolean } }
  | { pattern: { states: State[], animationMs: number } }
  | { random: { states: State[], animationMs: number, interpolate: boolean } }
  | { vrange: { states: State[], variable: string, min: number, max: number, interpolate: boolean } }

export function toEffectRaw(effect?: Effect): EffectRaw {
  let effectRaw: EffectRaw = { kind: "manual", states: [{color: null, intensity: null, power: null, temperature: null}], animationMs: 0, reverse: false, interpolate: false, min: 30, max: 300, variable: "motion.min", interleave: 0 };
  
  if (effect != null) {
    if ("manual" in effect) {
      effectRaw = { kind: "solid", states: [effect.manual], animationMs: 0, reverse: false, interpolate: true, min: 30, max: 300, variable: "motion.min", interleave: 0 }
    } else if ("solid" in effect) {
      effectRaw = { kind: "solid", ...effect.solid, min: 30, max: 300, variable: "motion.min", interpolate: true, reverse: false}
    } else if ("gradient" in effect) {
      effectRaw = { kind: "gradient", ...effect.gradient, min: 30, max: 300, variable: "motion.min", interleave: 0 }
    } else if ("pattern" in effect) {
      effectRaw = { kind: "pattern", ...effect.pattern, reverse: false, interpolate: true, min: 30, max: 300, variable: "motion.min", interleave: 0 }
    } else if ("random" in effect) {
      effectRaw = { kind: "random", ...effect.random, reverse: false, min: 30, max: 300, variable: "motion.min", interleave: 0 }
    } else if ("vrange" in effect) {
      effectRaw = { kind: "vrange", ...effect.vrange, animationMs: 0, reverse: false, interleave: 0 }
    }
  }

  effectRaw.states.forEach(state => {
    if (state.intensity !== null) {
      state.intensity = Math.floor(state.intensity * 100) / 100;
    }
  })

  return effectRaw;
}

export function fromEffectRaw(raw: EffectRaw): Effect {
  switch (raw.kind) {
    case "manual": return { manual: raw.states[0] };
    case "solid": return { solid: {...raw} };
    case "gradient": return { gradient: {...raw} };
    case "pattern": return { pattern: {...raw} };
    case "random": return { random: {...raw} };
    case "vrange": return { vrange: {...raw} };
  }
}

export interface EffectRaw {
  kind: "manual" | "solid" | "gradient" | "pattern" | "random" | "vrange"
  states: State[]
  animationMs: number
  reverse: boolean
  interpolate: boolean
  interleave: number
  variable: string
  min: number
  max: number
}