/*
 * Copyright 2015-2016 IBM Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import Foundation

public struct ActionToken {
    var actionName: String
    var actionCode: String
}

public struct TriggerToken {
    var triggerName: String
}

public struct RuleToken {
    var ruleName: String
    var triggerName: String
    var actionName: String
}

public struct SequenceToken {
    var sequenceName: String
    var actionNames: [String]
}

enum TokenState {
    case inStarComment
    case inSlashComment
    case initial
    case inClass
    case inClassName
    case inClassQualifier
    case skippingBlock
    case parseAction
}

open class WhiskTokenizer {
    
    
    var atPath: String!
    var toPath: String!
    var projectFileName: NSString!
    var targetName: String!
    
    public init(from: String, to: String, projectFile: NSString, target: String? ) {
        atPath = from
        toPath = to
        if target != nil {
            targetName = target!
        } else {
            targetName = "OpenWhiskActions"
        }
        self.projectFileName = projectFile
    }
    
    func readTargetSourceFiles() -> [String]? {
        let pbxProject = PBXProject(file: projectFileName as String, targetName: targetName)
        
        var filesForTarget = pbxProject.filesForTarget
        for (target, files) in filesForTarget {
            print("target:\(target), files:\(files)")
        }
        
        return filesForTarget[targetName]
    }
    
    open func readXCodeProjectDirectory() throws -> (actions: [Action],triggers: [Trigger], rules: [Rule], sequences: [Sequence]) {
        let dir: FileManager = FileManager.default
        
        var whiskActionArray = [Action]()
        var whiskTriggerArray = [Trigger]()
        var whiskRuleArray = [Rule]()
        var whiskSequenceArray = [Sequence]()
        
        if let fileList = readTargetSourceFiles() {
            
            print("There are \(fileList.count) files for target \(targetName)")
            
            if let enumerator: FileManager.DirectoryEnumerator = dir.enumerator(atPath: atPath) {
                
                while let item = enumerator.nextObject() as? NSString {
                    
                    var isDir = ObjCBool(false)
                    let fullPath = atPath+"/\(item)"
                    
                    //print("===== inspecting \(item.lastPathComponent)")
                    if dir.fileExists(atPath: fullPath, isDirectory: &isDir) == true {
                        if isDir.boolValue == true {
                            
                        }  else if item.hasSuffix(".swift") {
                            
                            if fileList.contains(item.lastPathComponent as String) {
                                print("****Processing \(item.lastPathComponent)")
                                do {
                                    let fileStr = try String(contentsOfFile: fullPath)
                                    if let entityTuple = getWhiskEntities(str: fileStr) {
                                        
                                        for action in entityTuple.actions {
                                            do {
                                                
                                                let actionDirPath = toPath+"/\(targetName!)"
                                                
                                                try FileManager.default.createDirectory(atPath: actionDirPath, withIntermediateDirectories: true, attributes: nil)
                                                
                                                let actionPath = actionDirPath+"/\(action.actionName).swift"
                                                
                                                let fileUrl = URL(fileURLWithPath: actionPath)
                                                try action.actionCode.write(to: fileUrl, atomically: false, encoding: String.Encoding.utf8)
                                                
                                                let whiskAction = Action(name: action.actionName as NSString, path: actionPath as NSString, runtime: Runtime.swift, parameters: nil)
                                                
                                                whiskActionArray.append(whiskAction)
                                                
                                            } catch {
                                                print("Error writing actions from Xcode \(error)")
                                            }
                                        }
                                        
                                        for trigger in entityTuple.triggers {
                                            let whiskTrigger = Trigger(name: trigger.triggerName as NSString, feed: nil, parameters: nil)
                                            whiskTriggerArray.append(whiskTrigger)
                                        }
                                        
                                        for rule in entityTuple.rules {
                                            let rule = Rule(name: rule.ruleName as NSString, trigger: rule.triggerName as NSString, action: rule.actionName as NSString)
                                            whiskRuleArray.append(rule)
                                        }
                                        
                                        for sequence in entityTuple.sequences {
                                            let seq = Sequence(name: sequence.sequenceName as NSString, actions: sequence.actionNames)
                                            whiskSequenceArray.append(seq)
                                        }
                                        
                                    }
                                    
                                } catch {
                                    print("Error \(error)")
                                }
                            }
                        }
                    }
                    
                }
            }
            
        } else {
            print("No files for given target \(targetName!)")
        }

        
        return (whiskActionArray, whiskTriggerArray, whiskRuleArray, whiskSequenceArray)
    }
    
    func getWhiskEntities(str: String) -> (actions: [ActionToken], triggers: [TriggerToken], rules: [RuleToken], sequences: [SequenceToken])? {
        
        let scanner = Scanner(string: str)
        
        var line: NSString?
        var state = TokenState.initial
        var actionArray = [ActionToken]()
        var triggerArray = [TriggerToken]()
        var ruleArray = [RuleToken]()
        var sequenceArray = [SequenceToken]()
        
        var actionName = ""
        var actionCode = ""
        var leftBracketCount = 0
        var rightBracketCount = 0
        
        
        while scanner.scanUpToCharacters(from: CharacterSet.newlines, into: &line) {
            
            // print("Scan location is \(scanner.scanLocation)")
            
            guard let line = line else {
                print("Xcode To Whisk: Error, line from tokenizer is nil, aborting.")
                return nil
            }
            
            var trimmedLine = line.trimmingCharacters(in: CharacterSet.whitespaces)
            
            if trimmedLine.hasPrefix("//") {
                //print("Skipping comment")
            } else if trimmedLine.hasPrefix("/*") {
                state = TokenState.inStarComment
            } else {
                
                switch state {
                case .initial:
                    if trimmedLine.range(of: "let") != nil && trimmedLine.range(of: "WhiskTrigger()") != nil {
                        
                        let classStr = trimmedLine.components(separatedBy: "=")
                        // get actionName
                        let letStr = classStr[0].components(separatedBy: .whitespaces)
                        let triggerName = letStr[1]
                        let triggerToken = TriggerToken(triggerName: triggerName)
                        triggerArray.append(triggerToken)
                        
                    } else if trimmedLine.range(of: "let") != nil && trimmedLine.range(of: "WhiskRule(") != nil && trimmedLine.range(of: "trigger:") != nil && trimmedLine.range(of: "action:") != nil{
                        var classStr = trimmedLine.components(separatedBy: "=")
                        let letStr = classStr[0].components(separatedBy: .whitespaces)
                        let ruleName = letStr[1].trimmingCharacters(in: .whitespacesAndNewlines)
                        
                        let paramStr = classStr[1].replacingOccurrences(of: "WhiskRule", with: "").components(separatedBy: ",")
                        let triggerStr = paramStr[0].components(separatedBy: ":")
                        let triggerName = triggerStr[1].trimmingCharacters(in: .whitespacesAndNewlines)
                        var actionStr = paramStr[1].components(separatedBy: ":")
                        let actionName = actionStr[1].replacingOccurrences(of: "(", with: "").replacingOccurrences(of: ")", with: "").trimmingCharacters(in: .whitespaces)
                        
                        
                        
                        print("Got trigger:\(triggerName), action:\(actionName)")
                        
                        let rule = RuleToken(ruleName: ruleName, triggerName: triggerName, actionName: actionName)
                        ruleArray.append(rule)
                        
                    } else if trimmedLine.range(of: "let") != nil && trimmedLine.range(of: "WhiskSequence(") != nil {
                        var classStr = trimmedLine.components(separatedBy: "=")
                        let letStr = classStr[0].components(separatedBy: .whitespaces)
                        let sequenceName = letStr[1]
                        
                        let paramStr = classStr[1].replacingOccurrences(of: "WhiskSequence", with: "").components(separatedBy: ":")
                        
                        let actionNames = paramStr[1].replacingOccurrences(of: "[", with: "").replacingOccurrences(of: "]", with: "").replacingOccurrences(of: "(", with: "").replacingOccurrences(of: ")", with: "").replacingOccurrences(of: " ", with: "")
                        
                        print("Got sequence \(actionNames)")
                        let names = actionNames.components(separatedBy: ",")
                        var sequenceActions = [String]()
                        for name in names {
                            sequenceActions.append(name)
                        }
                        let sequence = SequenceToken(sequenceName: sequenceName, actionNames: sequenceActions)
                        sequenceArray.append(sequence)
                        
                    } else if trimmedLine.range(of: "OpenWhiskAction") == nil && trimmedLine.range(of: "class") != nil && trimmedLine.range(of: ":") != nil && trimmedLine.range(of: "WhiskAction") != nil {
                        
                        let classStr = trimmedLine.components(separatedBy: ":")
                        
                        // get actionName
                        let classIndex = classStr[0].characters.index(classStr[0].startIndex, offsetBy: 6)
                        
                        actionName = classStr[0].substring(from: classIndex).trimmingCharacters(in: CharacterSet.whitespaces)
                        
                        state = TokenState.parseAction
                        var tok = trimmedLine.components(separatedBy: "{")
                        leftBracketCount = tok.count - 1
                        tok = trimmedLine.components(separatedBy: "}")
                        rightBracketCount = tok.count - 1
                        
                    }
                case .parseAction:
                    
                    var lookingForLeftBracket = false
                    if leftBracketCount == 0 {
                        lookingForLeftBracket = true
                    }
                    var tok = trimmedLine.components(separatedBy: "{")
                    leftBracketCount = leftBracketCount + (tok.count - 1)
                    tok = trimmedLine.components(separatedBy: "}")
                    rightBracketCount = rightBracketCount + (tok.count - 1)
                    
                    if leftBracketCount == rightBracketCount {
                        
                        // drop extra bracket
                        let lastLine = String(trimmedLine.characters.dropLast())
                        
                        if lookingForLeftBracket == false {
                            actionCode = actionCode + "\n" + lastLine
                        }
                        
                        let newAction = ActionToken(actionName: actionName, actionCode: actionCode)
                        
                        actionArray.append(newAction)
                        state = TokenState.initial
                        actionName = ""
                        actionCode = ""
                        
                        leftBracketCount = 0
                        rightBracketCount = 0
                        
                        state = TokenState.initial
                        
                    } else {
                        
                        let range = trimmedLine.range(of: "func run(")
                        if range != nil {
                            trimmedLine.replaceSubrange(range!, with: "func main(")
                        }
                        
                        if lookingForLeftBracket == false {
                            actionCode = actionCode + "\n"+trimmedLine
                        }
                    }
                    
                case .inStarComment:
                    if trimmedLine.hasSuffix("*/") {
                        state = TokenState.initial
                    }
                default:
                    //print("Don't care")
                    break
                }
            }
            
        }
        
        if state == .parseAction {
            let code = String(actionCode.characters.dropLast())
            let newAction = ActionToken(actionName: actionName, actionCode: code)
            actionArray.append(newAction)
            
        }
        
        return (actions: actionArray, triggers: triggerArray, rules: ruleArray, sequences: sequenceArray)
    }
    
}