require 'inifile'
require 'dbf'
require 'zip/zipfilesystem'
require 'tempfile'

module ICU
  class Tournament
    #
    # This is the format produced by the Windows program, SwissPerfect[http://www.swissperfect.com/]. It consists of three
    # files with the same name but different endings: <em>.ini</em> for meta data such as tournament name and tie-break
    # rules, <em>.trn</em> for the player details such as name and rating, and <em>.sco</em> for the results. The first
    # file is text and the other two are in an old binary format known as <em>DBase 3</em>.
    #
    # To parse such a set of files, use either the <em>parse_file!</em> or _parse_file_ method supplying the name of any one
    # of the three files or just the stem name without any ending. In case of error, such as any of the files not being
    # found, <em>parse_file!</em> will throw an exception while _parse_file_ will return _nil_ and record an error message.
    # As well as a file name or stem name, you should also supply a start date in the options as SwissPerfect does not
    # record this information.
    #
    #   parser = ICU::Tournament::SwissPerfect.new
    #   tournament = parser.parse_file('champs', :start => '2010-07-03')  # looks for "champs.ini", "champs.trn" and "champs.sco"
    #   puts tournament ? 'ok' : "problem: #{parser.error}"
    #
    # Alternatively, if all three files are in a ZIP archive, the parser will extract them if the name of the
    # archive file is supplied to the _parse_file_ method and it ends in ".zip" (case insensitive):
    #
    #   tournament = parser.parse_file('champs.zip', :start => '2010-07-03')
    #
    # Or, if the file is a ZIP archive but it's name doesn't end in ".zip", that can be signalled with an option:
    #
    #   tournament = parser.parse_file('/tmp/a84f21ge', :zip => true, :start => '2010-07-03')
    #
    # Note there must be only three files in the archive, they must all have the same stem name and
    # their endings should be ".ini", ".trn" and ".sco" (case insensitive).
    #
    # If no start date is supplied it will default to 2000-01-01, and can be reset later.
    #
    #   tournament = parser.parse_file('champs.zip')
    #   tournament.start                # => '2000-01-01'
    #   tournament.start = '2010-07-03'
    #
    # SwissPerfect files have slots for both local and international IDs and these, if present
    # and if intergers are copied to the _id_ and _fide_ attributes respectively.
    #
    # By default, the parser extracts the local rating from the SwissPerfect files and not the international one.
    # If international ratings are required instead, set the _rating_ option to "intl". For example:
    #
    #   tournament = parser.parse_file('ncc', :start => '2010-05-08')
    #   tournament.player(2).id         # =>  12379 (ICU ID)
    #   tournament.player(2).fide       # =>  1205064 (FIDE ID)
    #   tournament.player(2).rating     # =>  2556 (ICU rating)
    #
    #   tournament = parser.parse_file('ncc', :start => '2010-05-08', :rating => 'intl')
    #   tournament.player(2).rating     # =>  2530 (FIDE rating)
    #
    # By default, the parse will fail completely if the ".trn" file contains any invalid federations (see ICU::Federation).
    # There are two alternative behaviours controlled by setting the _fed_ option:
    #
    #   tournament = parser.parse_file('ncc', :start => '2010-05-08', :fed == 'skip')    # => silently skips invalid federations
    #   tournament = parser.parse_file('ncc', :start => '2010-05-08', :fed == 'ignore')  # => ignores all federations
    #
    # Note that federations that don't match 3 letters are always silently skipped.
    #
    # Because the data is in three parts, some of which are in a legacy binary format, serialization to this format is
    # not supported. Instead, a method is provided to serialize any tournament type into the text export format of
    # erfect, an example of which is shown below.
    #
    #   No  Name                 Loc Id  Total   1     2     3
    #
    #   1   Griffiths, Ryan-Rhys 6897    3       4:W   2:W   3:W
    #   2   Flynn, Jamie         5226    2       3:W   1:L   4:W
    #   3   Hulleman, Leon       6409    1       2:L   4:W   1:L
    #   4   Dunne, Thomas        10914   0       1:L   3:L   2:L
    #
    # This format is important in Irish chess, as it's the format used to submit results to the <em>MicroSoft Access</em>
    # implementation of the ICU ratings database.
    #
    #   swiss_perfect = tournament.serialize('SwissPerfect')
    #
    # The order of players in the serialized output is always by player number and as a side effect of serialization,
    # the player numbers will be adjusted to ensure they range from 1 to the total number of players (i.e. renumbered
    # in order). If you would prefer rank-order instead, then you must first renumber the players by rank (the default
    # renumbering method) before serializing. For example:
    #
    #   swiss_perfect = tournament.renumber.serialize('SwissPerfect')
    #
    # There should be no need to explicitly rank the tournament first, as that information is already present in
    # SwissPerfect files (i.e. each player should already have a rank after the files have been parsed).
    # Additionally, the tie break rules used for the tournament are available from the _tie_break_ method,
    # for example:
    #
    #   tournament.tie_breaks           # => [:buchholz, :harkness]
    #
    # Should you wish to rank the tournament using a different set of tie-break rules, you can do something like the following:
    #
    #   tournament.tie_breaks = [:wins, :blacks]
    #   swiss_perfect = tournament.rerank.renumber.serialize('SwissPerfect')
    #
    # See ICU::Tournament for more about tie-breaks.
    #
    class SwissPerfect
      attr_reader :error

      TRN = {
        :dob        => "BIRTH_DATE",
        :fed        => "FEDER",
        :first_name => "FIRSTNAME",
        :gender     => "SEX",
        :id         => "LOC_ID",
        :fide       => "INTL_ID",
        :last_name  => "SURNAME",
        :num        => "ID",
        :rank       => "ORDER",
        :rating     => ["LOC_RTG", "INTL_RTG"],
      } # not used: ABSENT BOARD CLUB FORB_PAIRS LATE_ENTRY LOC_RTG2 MEMO TEAM TECH_SCORE WITHDRAWAL (START_NO, BONUS used below)

      SCO = %w{ROUND WHITE BLACK W_SCORE B_SCORE W_TYPE B_TYPE}  # not used W_SUBSCO, B_SUBSCO

      # Parse SP data returning a Tournament or raising an exception on error.
      def parse_file!(file, arg={})
        @t = Tournament.new('Dummy', '2000-01-01')
        @t.start = arg[:start] if arg[:start]
        @bonus = {}
        @start_no = {}
        ini, trn, sco = get_files(file, arg)
        parse_ini(ini)
        parse_trn(trn, arg)
        parse_sco(sco)
        fixup
        @t.validate!(:rerank => true)
        @t
      end

      # Parse SP data returning an ICU::Tournament or a nil on failure. In the latter
      # case, an error message will be available via the <em>error</em> method.
      def parse_file(file, arg={})
        begin
          parse_file!(file, arg)
        rescue => ex
          @error = ex.message
          nil
        end
      end

      # Serialise a tournament to SwissPerfect text export format.
      def serialize(t, arg={})
        t.validate!(:type => self)

        # Ensure a nice set of numbers.
        t.renumber(:order)

        # Widths for the rank, name and ID and the number of rounds.
        m1 = t.players.inject(2) { |l, p| p.num.to_s.length  > l ? p.num.to_s.length  : l }
        m2 = t.players.inject(4) { |l, p| p.name.length      > l ? p.name.length      : l }
        m3 = t.players.inject(6) { |l, p| p.id.to_s.length   > l ? p.id.to_s.length   : l }
        rounds = t.last_round

        # The header, followed by a blank line.
        formats = ["%-#{m1}s", "%-#{m2}s", "%-#{m3}s", "%-5s"]
        (1..rounds).each { |r| formats << "%#{m1}d  " % r }
        sp = formats.join("\t") % ['No', 'Name', 'Loc Id', 'Total']
        sp << "\r\n\r\n"

        # Adjust the round parts of the formats for players results.
        (1..t.last_round).each { |r| formats[r+3] = "%#{m1+2}s" }

        # Now add a line for each player.
        t.players.each { |p| sp << p.to_sp_text(rounds, "#{formats.join(%Q{\t})}\r\n") }

        # And return the whole lot.
        sp
      end

      # Additional tournament validation rules for this specific type.
      def validate!(t)
        # None.
      end

      private

      def get_files(file, arg)
        file.match(/\.zip$/i) || arg[:zip] ? get_zip_files(file) : get_bare_files(file)
      end

      def get_bare_files(file)
        file.sub!(/\.\w+$/, '')
        %w(ini trn sco).map do |p|
          q = [p, p.upcase].detect { |r| File.file? "#{file}.#{r}" }
          raise "cannot find file #{file}.#{p}" unless q
          "#{file}.#{q}"
        end
      end

      def get_zip_files(file)
        temp = Hash.new
        begin
          Zip::ZipFile.open(file) do |zf|
            raise "ZIP file should contain exactly 3 files (.ini, .trn and .sco)" unless zf.size == 3
            stem = Hash.new
            zf.entries.each do |e|
              if e.file? && e.name.match(/^(.+)\.(ini|trn|sco)$/i)
                stm = $1
                ext = $2.downcase
                stem[ext] = stm
                tmp = Tempfile.new(e.name)
                pth = tmp.path
                tmp.close!
                e.extract(pth) { true }
                temp[ext] = pth
              end
            end
            %w(ini trn sco).each { |ext| raise "no #{ext.upcase} file found" unless stem[ext] }
            raise "different stem names found" unless stem['ini'] == stem['trn'] && stem['trn'] == stem['sco']
          end
        rescue Zip::ZipError
          raise "invalid ZIP file"
        rescue => ex
          raise ex
        end
        %w(ini trn sco).map { |ext| temp[ext] }
      end

      def parse_ini(file)
        begin
          ini = IniFile.load(file)
        rescue
          raise "invalid INI file"
        end
        raise "invalid INI file (no sections)" if ini.sections.size == 0
        %w(name arbiter rounds).each do |key|
          val = (ini['Tournament Info'][key.capitalize] || '').squeeze(" ").strip
          @t.send("#{key}=", val) if val.size > 0
        end
        @t.tie_breaks = ini['Standings']['Tie Breaks'].to_s.split(/,/).map do |tbid|
          case tbid.to_i              # tie break name in SwissPerfect
          when 1217 then :buchholz    # Buchholz
          when 1218 then :harkness    # Median Buchholz
          when 1219 then :progressive # cumulative
          when 1220 then :neustadtl   # Berger
          when 1221 then :ratings     # rating sum
          when 1222 then :wins        # number of wins
          when 1223 then nil          # minor scores - not applicable
          when 1226 then nil          # Brightwell   - not applicable
          else nil
          end
        end.find_all { |tb| tb }
      end

      def parse_trn(file, arg={})
        begin
          trn = DBF::Table.new(file)
        rescue
          raise "invalid TRN file"
        end
        raise "invalid TRN file (no records)" if trn.record_count == 0
        trn.each do |r|
          next unless r
          h = trn_record_to_hash(r, arg)
          @t.add_player(ICU::Player.new(h.delete(:first_name), h.delete(:last_name), h.delete(:num), h))
        end
      end

      def parse_sco(file)
        begin
          sco = DBF::Table.new(file)
        rescue
          raise "invalid SCO file"
        end
        raise "invalid SCO file (no records)" if sco.record_count == 0
        sco.each do |r|
          next unless r
          hs = sco_record_to_hashes(r)
          hs.each { |h| @t.add_result(ICU::Result.new(h.delete(:round), h.delete(:player), h.delete(:score), h)) }
        end
      end

      def trn_record_to_hash(r, arg={})
        @bonus[r.attributes["ID"]] = %w{BONUS MEMO}.inject(0.0){ |b,k| b > 0.0 ? b : r.attributes[k].to_f }
        @start_no[r.attributes["ID"]] = r.attributes["START_NO"]
        TRN.inject(Hash.new) do |hash, pair|
          key = pair[1]
          key = key[arg[pair[0]].to_s == 'intl' ? 1 : 0] if key.class == Array
          val = r.attributes[key]
          case pair[0]
          when :fed    then val = val && val.match(/^[A-Z]{3}$/i) ? val.upcase : nil
          when :gender then val = val.to_i > 0 ? %w(M F)[val.to_i-1] : nil
          when :id     then val = val.to_i > 0 ? val : nil
          when :fide   then val = val.to_i > 0 ? val : nil
          when :rating then val = val.to_i > 0 ? val : nil
          when :title  then val = val.to_i > 0 ? %w(GM WGM IM WIM FM WFM)[val.to_i-1] : nil
          end
          if pair[0] == :fed && val && arg[:fed]
            val = nil if arg[:fed].to_s == 'ignore'
            val = nil if arg[:fed].to_s == 'skip' && !ICU::Federation.find(val)
          end
          hash[pair[0]] = val unless val.nil? || val == ''
          hash
        end
      end

      def sco_record_to_hashes(record)
        r, w, b, ws, bs, wt, bt = SCO.map { |k| record.attributes[k] }
        hashes = []
        if w > 0 && b > 0 && ws + bs == 2
          hashes.push({ :round => r, :player => w, :score => %w(L D W)[ws], :opponent => b, :colour => 'W' })
          hashes.last[:rateable] = false unless wt == 1 && bt == 1
        else
          hashes.push({ :round => r, :player => w, :score => %w(L D W)[ws], :colour => 'W' }) if w > 0
          hashes.push({ :round => r, :player => b, :score => %w(L D W)[bs], :colour => 'B' }) if b > 0
        end
        hashes
      end

      def fixup
        fix_number_of_rounds
        fix_missing_results
        fix_bonuses
        fix_numbering
      end

      def fix_number_of_rounds
        rounds = @t.last_round
        @t.rounds = rounds
      end

      def fix_missing_results
        @t.players.each { |p| @t.add_result(ICU::Result.new(1, p.num, 'L')) if p.results.size == 0 }
      end

      def fix_bonuses
        @t.players.each do |p|
          bonus = @bonus[p.num] || 0
          next unless bonus > 0

          # Try to distribute the bonus in half-points to rounds where the player has no result.
          (1..@t.rounds).each do |r|
            result = p.find_result(r)
            next if result
            bonus = bonus - 0.5
            p.add_result(ICU::Result.new(r, p.num, 'D'))
            break if bonus <= 0
          end
          next unless bonus > 0

          # Try to distribute the bonus in half-points to rounds where the player has unrated results.
          (1..@t.rounds).each do |r|
            result = p.find_result(r)
            next unless result
            next if result.opponent
            next if result.score == 'W'
            bonus = bonus - 0.5
            result.score = result.score == 'D' ? 'W' : 'D'
            break if bonus <= 0
          end
        end
      end

      def fix_numbering
        @t.renumber(@start_no)
      end
    end
  end

  class Player
    # Format a player's record as it would appear in an SP text export file.
    def to_sp_text(rounds, format)
      attrs = [num.to_s, name, id.to_s, ('%.1f' % points).sub(/\.0/, '')]
      (1..rounds).each do |r|
        result = find_result(r)
        attrs << (result ? result.to_sp_text : " : ")
      end
      format % attrs
    end
  end

  class Result
    # Format a player's result as it would appear in an SP text export file.
    def to_sp_text
      sp = opponent ? opponent.to_s : '0'
      sp << ':'
      if rateable
        sp << score
      else
        sp << case score
        when 'W' then '+'
        when 'L' then '-'
        else '='
        end
      end
    end
  end
end