local db = require("lapis.db")
local to_json = require("lapis.util").to_json

local autoload = require("lapis.util").autoload
local models = autoload("models")

local function Splhandler(self)
  -- print( to_json(self.params))

  -- TODO: add auth-token

  -- secret=STATION_SECRET_#&
  -- artist_name=%a&
  -- track_name=%t&
  -- release_name=%T
  -- label=%L&
  -- year=%Y&
  -- country=%O&
  -- info_url=%U1&
  -- img_url=%U2&
  -- time=%h&
  -- date=%d&

  -- artist_name=%a&track_name=%t&release_name=%Tlabel=%L&year=%Y&country=%O&info_url=%U1&img_url=%U2&time=%h&date=%d&

  -- ----- --
  -- setup --
  -- ----- --

  local station_id = self.params.station

  local station = models.Stations:find({ station = station_id })
  if not station then
    print("unknown station: " .. station_id)
    return
  else
    print("This is: " .. station["name"])
  end

  local station_secret = os.getenv('STATION_SECRET_'..station_id) or nil
  local request_secret = self.params.secret
  if station_secret then
    if station_secret ~= request_secret then
      print("secrets not matching")
      return
    end
  end

  local artist = nil
  local artist_name = self.params.artist_name  -- mandatory

  local track = nil
  local track_name = self.params.track_name  -- mandatory
  local track_info_url = self.params.info_url or nil
  local track_img_url = self.params.img_url or "blanco.png"

  local release = nil
  local release_name = self.params.release_name or nil
  local release_year = tonumber(self.params.year) or nil

  local release_country = self.params.country or nil
  local release_label = self.params.label or nil

  local airtime = self.params.time  -- mandatory
  local airdate = self.params.date  -- mandatory

  -- check mandatory fields
  if not artist_name or not track_name or not airtime or not airdate then
    print("missing mandatory field")
    return
  end

  -- we have to split the `hr:min:sec` and `month/day/year` strings from SPL
  -- and since SPL uses both "." and "-" for dates .. somehow .. we have to do more dirty tricks ..
  local function Split(s, delimiters)

    for i, delimiter in ipairs(delimiters) do
      local result = {}

      if delimiter == "." then
        for match in string.gmatch(s, "[^%.]+") do
          table.insert(result, match)
        end
      else
        for match in (s..delimiter):gmatch("(.-)"..delimiter) do
            table.insert(result, match)
        end
      end

      if table.getn(result) == 3 then
        return result
      else
        print("something is wrong: ".. s)
      end

    end
  end

  local split_airtime = Split(airtime, {":"})
  local airtime_hr, airtime_min, airtime_sec = split_airtime[1], split_airtime[2], split_airtime[3]
  local split_airdate = Split(airdate, {"/", ".", "-"})
  local airdate_year, airdate_month, airdate_day = split_airdate[1], split_airdate[2], split_airdate[3]
  local airtime_stamp = os.time{year=airdate_year, month=airdate_month, day=airdate_day, hour=airtime_hr, min=airtime_min, sec=airtime_sec}


  -- ------- --
  -- queries --
  -- ------- --

  artist = models.Artists:find({ name=artist_name })
  if not artist then
    print("new artist: " .. artist_name)
    artist = models.Artists:create({
      name = artist_name
    })
  else
    print("old artist.")
  end

  -- make a unique name/identifier for the track using a combination of artist_name and track_name
  -- in lower-case and spaces removed
  local unique_track_name = artist_name .. track_name      -- prepend artist
  unique_track_name = unique_track_name:lower()           -- all to lowercase
  unique_track_name = unique_track_name:gsub("%s+", "")   -- remove spaces

  track = models.Tracks:find({ unique_name=unique_track_name })
  if not track then
    print("new track: " .. track_name)
    track = models.Tracks:create({
      name = track_name,
      unique_name = unique_track_name,
      year = release_year,
      info_url = track_info_url,
      img_url = track_img_url
    })
  else
    print("old track.")
  end

  -- track_artist
  local track_artist = models.Trackartists:find({ track=track["id"], artist=artist["id"] })
  if not track_artist then
    print("new track artist")
    track_artist = models.Trackartists:create({
      track=track["id"],
      artist=artist["id"]
    })
  end

  -- airtime
  local airtime = models.Airtimes:find({
    airtime = db.format_date(airtime_stamp),
    track = track["id"],
    station = station["id"]
  })
  if not airtime then
    airtime = models.Airtimes:create({
      airtime = db.format_date(airtime_stamp),
      track = track["id"],
      station = station["id"]
    })
  else
    print("already have this airtime! wtf??")
  end

  -- release
  if release_name:len() > 0 then
    release = models.Releases:find({ name=release_name })
    if not release then
      print("new release: " .. release_name)
      release = models.Releases:create({
        name = release_name,
        year = release_year,
        country = release_country,
        label = release_label
      })

    else
      print("old release.")
    end

    local track_release = models.Trackreleases:find({ track=track["id"], release=release["id"] })
    if not track_release then
      track_release = models.Trackreleases:create({ track=track["id"], release=release["id"] })
    end

  else
    print("no release, skipping")
  end

end

return Splhandler