#!/usr/bin/env ruby -KU

ENV["PATH"] = "/usr/local/bin/:/opt/local/bin:#{ENV["PATH"]}"

ENV["RAILS_ENV"] ||= "production"

require File.dirname(__FILE__) + "/../config/environment"

abort("Usage: #{$0} repo_id") unless ARGV[0]

$stdout.sync = true

def create_repo_creation_events_for(project)

  project.repository_clones.each do |repo|

    puts "creating Repository clone event in #{project.slug}/#{repo.name}"

   project.events.create({

     :action => Action::CLONE_REPOSITORY,

     :target => repo,

     :user => repo.user,

     :data => repo.parent_id,

     :created_at => repo.created_at

   })

  end

end

def create_comment_events_for(repo, project)

  repo.comments.each do |comment| 

    puts "creating Comment event on #{project.slug}/#{repo.name}"

    project.events.create({

      :action => Action::COMMENT,

      :target => comment,

      :user => comment.user,

      :created_at => comment.created_at

    })

  end

end

def create_merge_request_events_for(repo, project)

  repo.merge_requests.each do |mr|

    puts "creating MergeRequest event on #{project.slug}/#{repo.name}"

    project.events.create({

      :action => Action::REQUEST_MERGE,

      :target => mr,

      :user => mr.user,

      :created_at => mr.created_at,

    })

    unless mr.open?

      puts "creating MergeRequest resolvement event on #{project.slug}/#{repo.name}"

      project.events.create({

        :action => Action::RESOLVE_MERGE_REQUEST,

        :target => mr,

        :user => mr.user,

        :data => mr.status_string,

        :created_at => mr.created_at,

      })

    end

  end

end

def create_events_for_repository(repo, project)

  tag_map = repo.git.tags.inject({}){|hsh, t| hsh[t.commit.id] = t.name;hsh}

  parsed_commits = {} # Neccesary because of merge

  repo.git.heads.each do |head|

    users_commits = {}

    Grit::Commit.find_all(repo.git, head.name, {:since => "1 year ago"}).each do |commit|

      users_commits[commit.committer.email] ||= []

      users_commits[commit.committer.email] << commit

    end

    users = User.find(:all, :conditions => ['email in (?)', users_commits.keys] )

    users.each do |user|

      commits = users_commits[user.email]

      puts "\nindexing #{commits.size} commits for #{user.email} in #{project.slug}/#{repo.name}:#{head.name}"

      commits.each_index do |i|

        commit = commits[i]

        previous_commit = commits[i-1]

        newrev = commit.id

        next if parsed_commits.has_key?(newrev)

        parsed_commits[newrev] = true

        oldrev = previous_commit.id if previous_commit

        current_rev = newrev

        newtype = oldtype = current_rev_type = "commit"

        type = repo.git.git.name_rev({}, newrev).last.split("/").first

        if type != "tags"

          type = "heads"

        end

        action = :create

        if !oldrev

          action = :create

        else

          if commit.id =~ /^0+$/

            action = :delete

          else

            action = :update

          end

        end

        if action != :delete

          newtype = repo.git.git.cat_file({:t => true}, newrev)

        end

        if action == :update

          oldtype = repo.git.git.cat_file({:t => true}, oldrev)

        end

        if action == :delete

            current_rev = oldrev

            current_rev_type = oldtype

        end

        action_id = nil

        ref = nil

        if current_rev_type == "commit"

          if type == "heads"

            case action

              when :create

                action_id = Action::CREATE_BRANCH

                ref = head.name

              when :update

                action_id = Action::COMMIT

                ref = current_rev

              when :delete

                action_id = Action::DELETE_BRANCH

                ref = head.name

            end

          elsif type == "tags"

            if action == :create

              action_id = Action::CREATE_TAG

              ref = tag_map[commit.id]

            elsif action == :delete

              action_id = Action::DELETE_TAG

              ref = tag_map[commit.id]

            end

          end

        elsif current_rev_type == "tag"

          if type == "tags"

            if action == :create

              action_id = Action::CREATE_TAG

              ref = tag_map[commit.id]

            elsif action == :delete

              action_id = Action::DELETE_TAG

              ref = tag_map[commit.id]

            end

          end

        end

        print "." if (i % 10 == 1)

        #puts "#{current_rev_type}#{action.inspect} in #{project.slug}/#{repo.name}:#{head.name}: #{commit.short_message}"

        project.events.create({

          :action => action_id || Action::COMMIT, 

          :target => repo, 

          :user => user, 

          :body => commit.message, 

          :data => commit.id,

          :created_at => commit.committed_date})

      end

      commits = nil

      puts

    end

    users_commits = nil

  end

  parsed_commits = nil

end

def rebuild_project!(project)

  puts "Destroying existing events on #{project.slug}"

  project.events.destroy_all

  project.repositories.each do |repo|

    create_events_for_repository(repo, project)

    create_comment_events_for(repo, project)

    create_merge_request_events_for(repo, project)

  end

  create_repo_creation_events_for(project)

end

case ARGV[0]

when "all"

  Project.find(:all).each do |project|

    puts 

    puts "rebuilding #{project.slug}"

    puts

    begin

      rebuild_project!(project)

      GC.start

    rescue

      puts "!!! failed to rebuild #{project.slug} !!!"

      puts "#{e.class}:#{e.message} \n#{e.backtrace.join("\n  ")}"

      puts

      next

    end

  end

else

  project = Project.find(ARGV[0])

  rebuild_project!(project) if project

end