require './console'
fs = require 'fs'
path = require 'path'
request = require 'request'
exec = require('child_process').exec
sl = require('./serverList')
qsso = require './qsso'
schema = {}

# 创建schema接口地址
HOST = 'http://wanshiwu.corp.qunar.com'
URLS =
    "schema": "/schema/auto/create"
    "job": "/job/auto/create"

# qzz开发机列表
QZZDEVSERVERLIST = [
    'l-qzz1.fe.dev.cn6.qunar.com',
    'l-qzz2.fe.dev.cn6.qunar.com',
    'l-qzz3.fe.dev.cn6.qunar.com',
    'l-qzz4.fe.dev.cn6.qunar.com',
    'l-qzz5.fe.dev.cn6.qunar.com'
]

exports = module.exports = () ->

    if fs.existsSync(path.join(process.cwd(), '.schema'))
        console.red '已经初始化过schema，请查看.schema文件'
        process.exit()

    # qsso.login()
    getRepository((git) ->
        console.log 'node git工程:', git
        console.log '开始分析schema配置'
        schema = getSchema()
        schema.repository = git
        params = joinParams()
        requestCreateSchema(params, 'node', () ->
            createJob('node', git, (jobParams) ->
                writeSchemaBack(params, jobParams)
            )
        )

        if schema.qzz
            createQzzSchema()
    )

exports.getSchema = () ->
    return getSchema()

createJob = (mode, git, callback) ->
    console.log '开始创建', mode, 'job'

    params =
        "user_name": schema.username
        "src_root": git
        "qciviewpath": schema.qciPath
        "qdrviewpath": schema.qdrPath
        "targets": Object.keys(schema.serverList).join(',')

    options =
        "url": HOST + URLS.job
        "form": JSON.stringify(params)

    request.post(options, (err, httpResponse, body) ->
        if err isnt null
            console.red mode, 'job创建失败，原因:' + err
            process.exit()

        ret = JSON.parse(body.toString('utf-8'))

        if ret.status is true
            console.green mode, 'job创建成功，查看地址:', JSON.stringify(ret.content.joburls, null, 4)
            callback and callback(params)
        else
            console.red mode, 'job创建失败，原因:', ret.content
    )

writeSchemaBack = (params, jobParams) ->
    backFile = path.join(process.cwd(), '.schema')
    content =
        schema: params
        job: jobParams

    fs.writeFileSync(backFile, JSON.stringify(content, null, 4))

getSchema = () ->
    config = fs.readFileSync(path.join(process.cwd(), 'package.json')).toString 'utf-8'
    config = JSON.parse(config)
    schema = config.schema

    if !schema
        console.red '未找到schema配置，请确认package.json中是否含有schema配置'
        process.exit()

    return schema


createQzzSchema = () ->
    qzzGit = 'git@gitlab.corp.qunar.com:fe/' + schema.qzz + '.git'
    schema.qzzRepository = qzzGit
    console.log 'qzz git工程地址:', qzzGit

    params =
        "user_name": schema.username
        "mode": "3"
        "qzztype": "0"
        "git_root": qzzGit
        "build_group": ""
        "eminfo":
            "beta":
                "singlemode":
                    "server_list": ""
                    "rsync_exclude": ""
                    "server_listgroup": "ALL"
                    "service_name": ""
            "prod":
                "singlemode":
                    "server_list": ""
                    "rsync_exclude": ""
                    "server_listgroup": "ALL"
                    "service_name": ""
            "dev":
                "singlemode":
                    "server_list": QZZDEVSERVERLIST.join(',')
                    "rsync_exclude": ""
                    "server_listgroup": "ALL"
                    "service_name": ""

    requestCreateSchema(params, 'qzz', () ->
        createJob('qzz', qzzGit)
    )

requestCreateSchema = (params, mode, callback) ->
    console.log '开始创建', mode, 'schema'
    options =
        "url": HOST + URLS.schema
        "form": JSON.stringify(params)

    mode = mode || ''

    request.post(options, (err, httpResponse, body) ->
        if err isnt null
            console.red mode, 'schema创建失败，原因:' + err
            process.exit()

        ret = JSON.parse(body.toString('utf-8'))
        if ret.status is true
            console.green mode, 'schema创建成功，查看地址:', ret.content
            callback and callback()
        else
            console.red mode, 'schema创建失败，原因:', ret.content
    )


getRepository = (cb) ->

    repository = exec('git remote -v')

    repository.stdout.on 'data', (data) ->
        remoteInfo = data.toString('utf-8')
        gitMatchs = remoteInfo.split('\n')[0].match(/git@(.*)\.git/)
        if gitMatchs is null
            console.red '不是git工程，请确认后重新执行'
            process.exit()
        git = gitMatchs[0]
        cb(git)

    repository.stderr.on 'data', (err) ->
        if err.toString().indexOf 'Not a git repository' > -1
            console.red '不是git工程，请确认后重新执行'
        else
            console.red err
        process.exit()

    repository.on 'error', (err) ->
        console.log err
        process.exit()

joinParams = () ->

    wwwFolder = '/home/q/www'
    header = ''
    footer = ''
    hf = ''

    webapp = path.join(wwwFolder, schema.webapp)
    if schema.hf
        header = path.join(webapp, schema.hf, 'header')
        footer = path.join(webapp, schema.hf, 'footer')
        hf = path.join(webapp, schema.hf, 'prd')
    exclude = if schema.exclude then ',' + schema.exclude else ''

    params =
        "user_name": schema.username
        "mode": "0"
        "git_root": schema.repository
        "process_model": "branch_dev"
        "qzz_maven_enabled": if schema.qzz then "Y" else "N"
        "bds_mode": "file"
        "build_type": "prod"
        "eminfo": {}

    eminfo = params.eminfo
    for own env, server of schema.serverList
        eminfo[env] =
            "baseinfo":
                "build_group": "a"
                "build_command": "mvn -U clean compile"
                "sonar_check_metrics": ""
                "build_method": "custom"
            "singlemode":
                "svn_src_dir": "./"
                "check_urls": "http://127.0.0.1:" + schema.port + "/check_url"
                "pre_online": ""
                "server_list": addQunarToSever sl.parse(server)
                "header_path": header
                "server_listgroup": "ALL"
                "footer_path": footer
                "websrv_port": schema.port
                "auto_tomcat_app": "Y"
                "pre_offline": ""
                "healthcheck_root": webapp
                "server_template": ""
                "websrv_type": "static"
                "kill_9": "N"
                "rsync_exclude": "/logs/,/healthcheck.html,.svn,.git,.DS_Store"
                "coverage": "N"
                "header_footer_path": hf
                "rsync_dst": webapp
                "batch_num": ""
                "service_name": "qunar_" + schema.service
                "full_sync": "",
                "restart_websrv": "Y",
                "restart_nagios": "Y",
                "restart_healthcheck": "Y"

    return params

addQunarToSever = (serverList) ->
    for server, i in serverList
        if server.lastIndexOf('.qunar.com') < 0
            serverList[i] = server + '.qunar.com'

    return serverList.join(',')