require_relative "festwert"
require_relative "festwerteblock"
require_relative "kennlinie"
require_relative "kennfeld"
require_relative "stuetzstellenverteilung"

require_relative "label_list_comparison"

require_relative "../interfaces/dcm/label_list"
require_relative "../interfaces/lab/label_list"
require_relative "../interfaces/a2l/label_list"
require_relative "../interfaces/mfile/label_list"

require "set"
require_relative "../../core_ext"

class Ecu
  class LabelList
    include Enumerable

    def self.from_file(file_path)
      case File.extname(file_path)
      when ".lab" then self.from_lab(File.read_encoded(file_path))
      when ".a2l" then self.from_a2l(File.read_encoded(file_path))
      when ".dcm" then self.from_dcm(File.read_encoded(file_path))
      else fail "Unknown file extension: #{file_path}!"
      end
    end

    def self.labelclasses
      [
        Festwert,
        Festwerteblock,
        Kennlinie,
        Kennfeld,
        Stuetzstellenverteilung
      ]
    end

    def initialize(labels=[], headers=[], subheaders=[], safe=false)
      unless safe
        names = labels.map(&:name)
        if names.uniq.size != names.size
          duplicates = names.select { |name| names.count(name) > 1 }.uniq
          fail ArgumentError,
            "Label list must not contain duplicates: #{duplicates.join(", ")}"
        end
      end
      @labels     = labels
      @headers    = headers
      @subheaders = subheaders
    end

    attr_accessor :headers, :subheaders

    def <<(label)
      unless self.class.labelclasses.any? { |klass| label.is_a?(klass) }
        fail ArgumentError, "Can only add recognised labels"
      end
      if self.map(&:name).include? label.name
        fail ArgumentError, "Cannot add duplicate labels"
      end
      @labels << label
    end

    def ==(other)
      @labels.all? do |label|
        other.find { |l| l == label }
      end
    end

    def each(&blk)
      @labels.each(&blk)
    end

    def map_int(&blk)
      self.class.new(@labels.map(&blk), @headers, @subheaders)
    end

    def select(&blk)
      self.class.new(@labels.select(&blk), @headers, @subheaders)
    end

    def reject!(&blk)
      @labels.reject!(&blk)
    end

    def reject(&blk)
      self.class.new(@labels.reject(&blk), @headers, @subheaders)
    end

    def with(headers: [], subheaders: [])
      self.class.new(@labels, headers, subheaders)
    end

    def delete_if(&blk)
      @labels.delete_if(&blk)
    end

    def group_by(&blk)
      @labels.group_by(&blk).map { |k, v| [k, self.class.new(v)] }.to_h
    end

    def sort_by(&blk)
      self.class.new(@labels.sort_by(&blk), @headers, @subheaders)
    end

    def merge(other)
      LabelListComparison.new(self, other).merge(priority: :right)
    end

    def merge!(other)
      merged      = merge(other)
      @labels     = merged.to_a
      @headers    = merged.headers
      @subheaders = merged.subheaders
    end

    def +(other) = merge(other)
    def to_s = "[#{@labels.map(&:to_s).join(", ")}]"
    def inspect = to_s
    def size = count
    def empty? = @labels.empty?
    def contains?(name) = map(&:name).include?(name)
    def to_a = @labels

  end
end