#!/usr/pkg/bin/ruby

require 'nkf'
require 'pp'
require 'pstore'
require 'date'
require "cgi"
require './tagcloud'

class Entry
  attr_accessor :year
  attr_accessor :title
  attr_accessor :cast
  attr_accessor :place
  attr_accessor :sheet
  attr_accessor :open
  attr_accessor :start

  def initialize
    @year = ""
    @title = ""
    @cast = ""
    @place = ""
    @sheet = ""
    @open = ""
    @start = ""
  end
end

class EntryList < Array
  def initialize
  end
  
  def add( entry )
    self << entry
  end
  
  def entryeach( year )
    self.each { |e|
      if year == nil || year == ''
        yield e
      else
        y = e.year.split( '/' )[ 0 ]
        if y == year
          yield e
        end
      end
    }
  end
  
end

class EventData
  def initialize( eventfile, cachefile )
    @cachefile = cachefile
    @eventfile = eventfile
    @lastupdate = nil
  end
  
  def lastupdate
    @lastupdate
  end

  
  def entries
    @entries = nil
    db = PStore.new( @cachefile )
    db.transaction do
      updated = db[ :updated ]
      eventfileupdated = File.mtime( @eventfile )
      if updated && updated > eventfileupdated
        @entries = db[ :entries ]
        @lastupdate = updated
      else
        @entries = EntryList.new
        File.open( @eventfile ) { |file|
          file.each { |line|
#            l = NKF::nkf( '-s', line )
    #        puts l
#            prm = l.split( /,/, 7 )
            prm = line.split( /,/, 7 )

            entry = Entry.new
            entry.year =  prm[ 0 ] || ""
            entry.title = prm[ 1 ] || ""
            entry.cast = prm[ 2 ] || ""
            entry.place = prm[ 3 ] || ""
            entry.sheet = prm[ 4 ] || ""
            entry.open = prm[ 5 ] || ""
            entry.start = prm[ 6 ] || ""
            @entries << entry
          }
        }
        
        db[ :updated ] = eventfileupdated
        db[ :entries ] = @entries

        @lastupdate = eventfileupdated

      end
      
      return @entries

    end
  end
  
end ## of EventData

class Summary
  def initialize( eventdata )
    @eventdata = eventdata
    @entries = @eventdata.entries
  end

  def year( y )
    contents = ""
    contents << header
    contents << getentries( y )
    contents << footer
    contents
  end
  
  def header
<<EOS
    <center>
    <table frame=border rules=all border="1" cellspacing="0" cellpadding="4">
    <tr>
    <th>日付</th>
    <th>内容</th>
    <th>出演者</th>
    <th>場所</th>
    <th>席</th>
    <th>開場時刻</th>
    <th>開演時刻</th>
    </tr>
EOS
  end
  
  def footer
<<EOS
    </table>
    </center>
EOS
  end
  
  def getentries( year )
    contents = ""
    @entries.entryeach( year ) { |e|
      contents << "<tr><td>"
      contents <<  e.year
      contents << "</td><td>"
      contents << e.title
      contents << "</td><td>"
      contents <<  e.cast
      contents << "</td><td>"
      contents <<  e.place
      contents << "</td><td>"
      contents << e.sheet
      contents << "</td><td>"
      contents << e.open
      contents << "</td><td>"
      contents << e.start
      contents << "</td></tr>"
      contents << "\n"
    }
  
    return contents
  end

end ## of Summary

class Total
  def initialize( eventdata, cachefile )
    @eventdata = eventdata
    @entries = @eventdata.entries
    @cachefile = cachefile
    @lastupdate = @eventdata.lastupdate
  end

  def lastupdate
    @lastupdate
  end
  
  def year( y )
    yr = ""
    if y == nil || y == ""
      yr = "全部"
    else
      yr = "#{y}年"
    end

    contents = ""
    contents << header( yr )
    contents << getentries( y )
    contents << footer
    contents
  end

  def header( range )
<<EOS
    #{range}<br>
    <table frame=border rules=all border="1" cellspacing="0" cellpadding="4">
    <tr>
    <th>出演者</th>
    <th>回数</th>
    </tr>
EOS
  end
  
  def footer
<<EOS
    </table>
EOS
  end

  def counting( year )
    count = nil

    db = PStore.new( @cachefile )
    db.transaction do
      db[ year ] ||= []
      updated = db[ :updated ]
      eventupdated = @eventdata.lastupdate
      if updated && updated > eventupdated
        count = db[ year ]
        @lastupdate = updated
      else
        count = {}
        count.default = 0
        @entries.entryeach( year ) { |e|
          casts = e.cast.split( / / )
          casts.each { |c|
            count[ c ] += 1
          }
        }
        
        db[ :updated ] = eventupdated
        db[ year ].push( count )

        @lastupdate = eventupdated
        
      end
    
    end
    
    return count
  end

  def getentries( year )
    count = counting( year )
    ar = count.to_a
    ar.sort! { |a, b| b[1] <=> a[1] }

    contents = ""
    ar.each { |c|
      contents << "<tr><td>"
      contents << c[ 0 ]
      contents << "</td><td>"
      contents << c[ 1 ].to_s
      contents << "</td></tr>"
      contents << "\n"
    }
  
    return contents

  end

end ## of Total

class Tagcloud
  def initialize( eventdata, cachefile, total )
    @eventdata = eventdata
    @entries = @eventdata.entries
    @cachefile = cachefile
    @total = total
  end

  def year( y )
    yr = ""
    if y == nil || y == ""
      yr = "全部"
    else
      yr = "#{y}年"
    end

    contents = ""
    contents << header( yr )
    contents << getentries( y )
    contents << footer
    contents
  end

  def header( range )
<<EOS
    #{range}<br>
    </tr>
EOS
  end
  
  def footer
    ""
  end

  def getentries( year )
    count = @total.counting( year )
    tags = []
    count.each { |cast, count|
      tags << Hash[ :tag => cast, :count => count ]
    }
    
    cloud = tagcloud( tags, year )
    return cloud
    
  end
  
  def tagcloud( tags, year )
    cloud = nil

    db = PStore.new( @cachefile )
    db.transaction do
      db[ year ] ||= []
      updated = db[ :updated ]
      totalupdated = @total.lastupdate
      if updated && updated > totalupdated
        cloud = db[ year ]
        @lastupdate = updated
      else
        cloud = TagCloud.new
        tags.each { |t|
         cloud.add( t[:tag], "http://www.google.co.jp/search?q=#{t[:tag]}", t[:count])
        }
        
        db[ :updated ] = totalupdated
        db[ year ].push( cloud )
      end
    end

    return cloud.html_and_css( 50 )

  end
  
end ## of Tagcloud



class Page
  def initialize( cgi )
    @cgi = cgi
  end
  
  def create
    cgi = CGI.new("html3")
    cgi.out() do
      cgi.html() do
        cgi.head{ cgi.title{"miwarin's event list"} } +
        cgi.body() do
          mode = cgi[ 'mode' ]
          year = cgi[ 'year' ]
          if mode == ''
            buildmenu
          else
            buildcontents( mode, year )
          end

        end
      end
    end
  end ## create

  def buildmenu
    start = 1998
    nowyear = Date.today.year
    summaries = ""
    summaries << "summay<br>"
    totals = ""
    totals << "total<br>"
    tags = ""
    tags << "tagcloud<br>"
    
    start.step( nowyear ) { |year|
      sum = "./index.rb?mode=summary&year=#{year}"
      summaries << "<a href=\"#{sum}\">#{year}</a><br>"
  
      tl = "./index.rb?mode=total&year=#{year}"
      totals << "<a href=\"#{tl}\">#{year}</a><br>"
  
      tc = "./index.rb?mode=tagcloud&year=#{year}"
      tags << "<a href=\"#{tc}\">#{year}</a><br>"
      
    }
  
    sum = "./index.rb?mode=summary"
    summaries << "<a href=\"#{sum}\">all</a><br>"
  
    tl = "./index.rb?mode=total"
    totals << "<a href=\"#{tl}\">all</a><br>"
    
    tc = "./index.rb?mode=tagcloud"
    tags << "<a href=\"#{tc}\">all</a><br>"
  
    menus = ""
    menus << "<a href=\"../\">top</a><br>"
    menus << "<hr>"
    menus << summaries
    menus << "<hr>"
    menus << totals
    menus << "<hr>"
    menus << tags
    menus << "<hr>"
    
    return menus
  
  end ## of buildmenu
  
  
  def buildcontents( mode, year )
    data = EventData.new( "./event.csv", "./event.db" )
    builder = createbuilder( data, mode, year )
    contents = builder.year( year )
    return contents
  end ## of buildcontents

  def createbuilder( data, ope, year )
    contentsbuilder = nil
  
    case ope
    when 'summary'
      contentsbuilder = Summary.new( data )
    when 'total'
      contentsbuilder = Total.new( data, "./total.db"  )
    when 'tagcloud'
      contentsbuilder = Tagcloud.new( data, "./tag.db", Total.new( data, "./total.db" ) )
    end
    
    return contentsbuilder
    
  end ## of createbuilder

end ## of Page

def main
  cgi = CGI.new
  page = Page.new( cgi )
  page.create
end

main