require "scms/version"

module Scms
    require 'scms/scms-utils.rb'
    require 'scms/s3deploy.rb'

    require 'erb'
    require 'ostruct' 
    require 'yaml'
    require 'sass'
    require 'packr'
    require 'maruku'
    
    include YAML
    
    def Scms.build(website, config, mode)
        @website = website
        @mode = mode
        #ScmsUtils.log("Mode: #{mode}")
        
        ScmsUtils.log("Website #{@website}")
        Scms.sassall(File.join(@website))
        
        yamlpath=File.join(config, "_config.yml")
        @settings = ScmsUtils.getsettings(yamlpath)
        if @settings           
            #Bootstrap here
            if @settings["bootstrap"] != nil
                bootstrap = File.join(@website, @settings["bootstrap"])
                #ScmsUtils.log("Bootstrap is: #{@settings["bootstrap"]}")
                if File.exists?(bootstrap)
                    begin
                        require_relative bootstrap
                    rescue Exception=>e
                        ScmsUtils.errLog(e.message)
                        ScmsUtils.log(e.backtrace.inspect  )
                    end
                else
                    ScmsUtils.log("Bootstrap does not exist #{bootstrap}")
                end
            end 
            
            bundles = Scms.bundle(@settings["bundles"])
            Scms.parsepages(bundles)
        else
            ScmsUtils.errLog("Config is empty")
        end

        ScmsUtils.log("Built website:")
        ScmsUtils.log(ScmsUtils.uriEncode("file:///#{@website}"))
    end

    def Scms.parsepages(bundles)
        # build views from templates
        @template = @settings["template"] 
        
        if @settings["pages"] != nil
            # Build navigation
            navigation = Array.new
            @settings["pages"].each do |pagedata|
                if pagedata != nil
                    pagedata.each do |pageoptions|
                        pagename =  pageoptions[0]
                        pageconfig = pageoptions[1]
                        pageurl = pageconfig["generate"]
                        pageurl = pageconfig["url"] unless pageconfig["url"] == nil
                        navtext = pageconfig["navigation"]
                        navmeta = pageconfig["navigation_meta"]
                        navigation.push({"text" => navtext, "url" => pageurl, "pagename" => pagename, "meta" => navmeta}) unless navtext == nil
                    end
                end
            end

            ScmsUtils.log("Compiling Pages:")
            @settings["pages"].each do |pagedata|
                if pagedata != nil
                    pagedata.each do |pageoptions|
                        pagename =  pageoptions[0]
                        pageconfig = pageoptions[1]
                        pageurl = pageconfig["generate"]
                        title = pagename
                        title = pageconfig["title"] unless pageconfig["title"] == nil
                        description = pageconfig["description"]
                        keywords = pageconfig["keywords"]

                        skin = @template
                        skin = pageconfig["template"] unless pageconfig["template"] == nil
                        
                        resource = Hash.new
                        if pageconfig["resource"] != nil
                            resourcepath = File.join(@website, pageconfig["resource"])
                            if File.exists?(resourcepath)
                                #ScmsUtils.log( "_Resource found: #{pageconfig["resource"]}_" )
                                resource = YAML.load_file(resourcepath)
                            else
                                ScmsUtils.errLog( "Resource not found: #{resourcepath}" )
                            end
                        end
                        
                        hasHandler = false
                        if pageconfig["handler"] != nil
                            handlerpath = File.join(@website, pageconfig["handler"])
                            if File.exists?(handlerpath)
                                #ScmsUtils.log( "Handler found: #{pageconfig["handler"]}" )
                                require handlerpath
                                funDefined = defined? Handler.render
                                if funDefined != nil
                                    hasHandler = true
                                else
                                    ScmsUtils.errLog( "Handler doesnt have a render method" )
                                end
                            else
                                ScmsUtils.errLog( "**Handler not found: #{handlerpath}**" )
                            end
                        end
                        
                        views = Hash.new
                        if pageconfig["views"] != nil
                            pageconfig["views"].each do |view| 
                                views[view[0]] = ""
                                viewpath = File.join(@website, view[1])
                                if File.exists?(viewpath)
                                    htmlsnipet = File.read(viewpath)
                                    if !htmlsnipet.empty?
                                        viewmodel = Hash.new
                                        viewmodel = { 
                                            :name => pagename,
                                            :title => title,
                                            :url => pageurl,
                                            :data => pagedata,
                                            :rootdir => @website, 
                                            :resource => resource 
                                        }

                                        if hasHandler
                                            ScmsUtils.log("Rendering with handler")
                                            viewSnippet = Handler.render(viewpath)
                                        else
                                            snnipetCode = File.read(viewpath)
                                            case File.extname(view[1])
                                            when ".md"
                                                begin  
                                                    doc = Maruku.new(snnipetCode)
                                                    viewSnippet = doc.to_html
                                                rescue Exception => e  
                                                    viewSnippet = snnipetCode
                                                    puts e.message  
                                                    puts e.backtrace.inspect  
                                                end
                                            else
                                              viewSnippet = snnipetCode
                                            end
                                        end
                                        
                                        if @mode == "cms"
                                            views[view[0]] = "<div class='cms' data-view='#{view[1]}' data-page='#{pageurl}'>#{Scms.parsetemplate(viewSnippet, viewmodel)}</div>"
                                        else
                                            views[view[0]] = Scms.parsetemplate(viewSnippet, viewmodel)
                                        end
                                    else
                                        ScmsUtils.writelog("Empty file: #{viewpath}")
                                    end
                                else
                                    ScmsUtils.errLog("View not found: #{view[0]} - #{view[1]} [#{viewpath}]")
                                    ScmsUtils.writelog("View not found: #{view[0]} - #{view[1]} [#{viewpath}]")
                                end
                                #ScmsUtils.log( "view = #{view[0]} - #{view[1]}" )
                            end
                        end

                        monkeyhook = "";
                        monkeyhook = "<script src='scripts/air-monkey-hook.js'></script>" if @mode == "cms"
                        
                        pagemodel = Hash.new
                        pagemodel = { 
                            :name => pagename,
                            :title => title,
                            :description => description,
                            :keywords => keywords,
                            :url => pageurl,
                            :views => views, 
                            :resource => resource, 
                            :config => pageconfig, 
                            :bundles => bundles,
                            :navigation => navigation,
                            :data => pagedata,
                            :rootdir => @website, 
                            :monkeyhook => monkeyhook
                        }
                        
                        erb = File.join(@website, skin)
                        out = File.join(@website, File.join(pageconfig["generate"].sub('~/',''))) unless pageconfig["generate"] == nil
                        
                        ScmsUtils.successLog("#{pageurl}")
                        ScmsUtils.errLog("Template doesn't exist: #{erb}") unless File.exists?(erb)
                        if File.exists?(erb) && out != nil
                            pubsubdir = File.dirname(out)
                            Dir.mkdir(pubsubdir, 755) unless File::directory?(pubsubdir)

                            erbtemplate = File.read(erb)
                            erbtemplate = erbtemplate.gsub('data.','page.')#lagasy fix
                            File.open(erb, 'w') {|f| f.write(erbtemplate) }#lagasy fix

                            html = Scms.parsetemplate(erbtemplate, pagemodel)

                            html = html.gsub('~/', ScmsUtils.uriEncode("file:///#{@website}/")) if @mode == "cms"
                            websiteroot = '/'
                            websiteroot = @settings["url"] unless @settings["rooturl"] == nil

                            html = html.gsub('~/', websiteroot)

                            File.open(out, 'w') {|f| f.write(html) }
                        end
                    end
                end
                #ScmsUtils.log( out )
            end
        end
    end

    def Scms.parsetemplate(template, hash)
        page = OpenStruct.new(hash)
        result = ""
        
        begin 
            result = ERB.new(template).result(page.instance_eval { binding })
        rescue Exception => e  
                    ScmsUtils.errLog("Critical Error: Could not parse template")
                    ScmsUtils.log( "(if your using resources make sure their not empty)" )
                    ScmsUtils.errLog( e.message )
        end
        
        return result
    end

    def Scms.bundle(bundleConfig)
        bundles = Hash.new
        if bundleConfig != nil
            ScmsUtils.log("Bundeling:")
            bundleConfig.each do |bundle|
                #ScmsUtils.log( "bundle (#{bundle.class}) = #{bundle}" )
                bundle.each do |option|
                    name = option[0]
                    bundleName = File.join(option[1]["generate"])
                    bundles[name] = bundleName
                    ScmsUtils.successLog("#{bundleName}")

                    content = ""
                    assetList = ""
                    files = option[1]["files"]
                    if files != nil
                        files.each do |asset|
                            assetList += "\t#{asset}\n" 
                            assetname = File.join(@website, asset)
                            if File::exists?(assetname)
                                content = content + "\n" + File.read(assetname)
                            else
                                ScmsUtils.errLog( "Error: No such file #{assetname}" )
                            end
                        end
                        ScmsUtils.log("#{assetList}")
                        
                        bundleDir = File.dirname(bundleName)
                        Dir.mkdir(bundleDir, 755) unless File::directory?(bundleDir)
                        File.open(bundleName, 'w') {|f| f.write(content) }
                        if File.extname(bundleName) == ".js"
                            puts "Minifing: #{bundleName}"
                            Scms.packr(bundleName) unless /(-min)|(\.min)/.match(bundleName)
                        end
                    else
                        ScmsUtils.errLog("No files in bundle"); 
                    end
                end
            end
        end
        return bundles
    end

    def Scms.sassall(crunchDir)
        ScmsUtils.log("Minimising Sass Files (.scss)")
        Dir.chdir(crunchDir) do
            Dir.glob("**/*.{scss}").each do |asset|
                Scms.sass(asset)
            end
        end
    end

    def Scms.sass(asset)
        if File.exists?(asset)
            begin
                template = File.read(asset)
                sass_engine = Sass::Engine.new(template, {
                                                          :style => :compressed,
                                                          :cache => false,
                                                          :syntax => :scss
                                                         }.freeze)
                output = sass_engine.to_css
                css_file = "#{File.dirname(asset)}/#{File.basename(asset,'.*')}.css"
                File.open(css_file, 'w') { |file| file.write(output) }
                ScmsUtils.log( "_Sassed: #{css_file}_" )
            rescue Exception => e  
                ScmsUtils.errLog( "Error processing: #{asset}" )
                ScmsUtils.errLog( e.message )
            end
        end
    end
    
    def Scms.packr(asset)
        if File.exists?(asset)
            begin
                code = File.read(asset)
                compressed = Packr.pack(code)
                File.open(asset, 'w') { |f| f.write(compressed) }
                ScmsUtils.log( "Minified #{File.basename(asset)}" )
            rescue Exception => e  
                ScmsUtils.errLog( "Error processing: #{asset}" )
                ScmsUtils.errLog( e.message )
            end
        end
    end

    def Scms.copywebsite(website, pub)
        if pub.to_s.strip.length != 0
            FileUtils.mkdir pub unless Dir.exists? pub
            source = File.join(website)
            Dir.chdir(source) do          
                Dir.glob("**/*").reject{|f| f['.svn']}.each do |oldfile|
                  newfile = File.join(pub, oldfile.sub(source, ''))
                  #puts newfile
                  File.file?(oldfile) ? FileUtils.copy(oldfile, newfile) : FileUtils.mkdir(newfile) unless File.exist? newfile
                end
            end
            ScmsUtils.log("Output to: #{ScmsUtils.uriEncode("file:///#{pub}")}")
        end
    end

    def Scms.upgrade(website)
        File.rename("config.yml", "_config.yml") if File.exists? File.join(website, "config.yml")
        File.rename("s3config.yml", "_s3config.yml") if File.exists? File.join(website, "s3config.yml")
    end
end