apply plugin: 'groovy'
apply plugin: 'maven'

dependencies {
  compile gradleApi()
  compile localGroovy()
}

repositories {
  mavenCentral()
}

package cn.edu.zafu.gradle

import org.gradle.api.Plugin
import org.gradle.api.Project

public class PluginImpl implements Plugin<Project> {
  void apply(Project project) {
    project.task('testTask') << {
      println "Hello gradle plugin"
    }
  }
}

implementation-class=cn.edu.zafu.gradle.PluginImpl

repositories {
  mavenCentral()
}
group='cn.edu.zafu.gradle.plugin'
version='1.0.0'

uploadArchives {
  repositories {
    mavenDeployer {
      repository(url: uri('../repo'))
    }
  }
}

buildscript {
  repositories {
    maven {
      url uri('../repo')
    }
  }
  dependencies {
    classpath 'cn.edu.zafu.gradle.plugin:time:1.0.0'
  }
}
apply plugin: 'plugin.test'

dependencies {
    classpath 'com.android.tools.build:gradle:2.0.0-beta6'
    classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.0'
    classpath 'com.github.dcendents:android-maven-plugin:1.2'
  }

apply plugin: 'com.jfrog.bintray'
apply plugin: 'maven-publish'

def projectName = "timePlugin"
def mavenDesc = 'your desc'
def baseUrl = 'https://github.com/yourBaseUrl'
def siteUrl = baseUrl
def gitUrl = "${baseUrl}/yourGitUrl"
def issueUrl = "${baseUrl}/yourGitIssueUrl"

def licenseIds = ['Apache-2.0']
def licenseNames = ['The Apache Software License, Version 2.0']
def licenseUrls = ['http://www.apache.org/licenses/LICENSE-2.0.txt']
def inception = '2016'

def username = 'lizhangqu'

install {
  repositories {
    mavenInstaller {
      pom.project {
        // Description
        name projectName
        description mavenDesc
        url siteUrl

        // Archive
        groupId project.group
        artifactId archivesBaseName
        version project.version

        // License
        inceptionYear inception
        licenses {
          licenseNames.eachWithIndex { ln, li ->
            license {
              name ln
              url licenseUrls[li]
            }
          }
        }
        developers {
          developer {
            name username
          }
        }
        scm {
          connection gitUrl
          developerConnection gitUrl
          url siteUrl
        }
      }
    }
  }
}

task sourcesJar(type: Jar) {
  from sourceSets.main.allGroovy
  classifier = 'sources'
}


task javadocJar(type: Jar, dependsOn: groovydoc) {
  from groovydoc.destinationDir
  classifier = 'javadoc'
}

artifacts {
  archives javadocJar
  archives sourcesJar
}


bintray {
  user = BINTRAY_USER
  key = BINTRAY_KEY
  configurations = ['archives']
  pkg {
    repo = 'maven'
    name = projectName
    desc = mavenDesc
    websiteUrl = siteUrl
    issueTrackerUrl = issueUrl
    vcsUrl = gitUrl
    labels = ['gradle', 'plugin', 'time']
    licenses = licenseIds
    publish = true
    publicDownloadNumbers = true
  }
}

apply from: '../bintray.gradle'

    maven {
      url uri('../repo')
    }

jcenter()

buildscript {
  repositories {
    jcenter()
    maven {
      url uri('../repo')
    }
  }
  dependencies {
    classpath 'cn.edu.zafu.gradle.plugin:time:1.0.0'
  }
}

apply plugin: 'plugin.test'

package cn.edu.zafu.gradle

import org.gradle.BuildListener
import org.gradle.BuildResult
import org.gradle.api.Task
import org.gradle.api.execution.TaskExecutionListener
import org.gradle.api.initialization.Settings
import org.gradle.api.invocation.Gradle
import org.gradle.api.tasks.TaskState
import org.gradle.util.Clock

class TimeListener implements TaskExecutionListener, BuildListener {
  private Clock clock
  private times = []

  @Override
  void beforeExecute(Task task) {
    clock = new org.gradle.util.Clock()
  }

  @Override
  void afterExecute(Task task, TaskState taskState) {
    def ms = clock.timeInMs
    times.add([ms, task.path])
    task.project.logger.warn "${task.path} spend ${ms}ms"
  }

  @Override
  void buildFinished(BuildResult result) {
    println "Task spend time:"
    for (time in times) {
      if (time[0] >= 50) {
        printf "%7sms %s\n", time
      }
    }
  }

  @Override
  void buildStarted(Gradle gradle) {}

  @Override
  void projectsEvaluated(Gradle gradle) {}

  @Override
  void projectsLoaded(Gradle gradle) {}

  @Override
  void settingsEvaluated(Settings settings) {}
}

void apply(Project project) {
    project.gradle.addListener(new TimeListener())
  }

buildscript {
  repositories {
    jcenter()
  }
  dependencies {
    classpath 'cn.edu.zafu.gradle.plugin:time:1.0.0'
  }
}

apply plugin: 'plugin.time'

public class PluginExtension {
  def param1 = "param1 defaut"
  def param2 = "param2 defaut"
  def param3 = "param3 defaut"
}

public class PluginNestExtension {
  def nestParam1 = "nestParam1 defaut"
  def nestParam2 = "nestParam2 defaut"
  def nestParam3 = "nestParam3 defaut"
}

public class CustomTask extends DefaultTask {

  @TaskAction
  void output() {
    println "param1 is ${project.pluginExt.param1}"
    println "param2 is ${project.pluginExt.param2}"
    println "param3 is ${project.pluginExt.param3}"
    println "nestparam1 is ${project.pluginExt.nestExt.nestParam1}"
    println "nestparam2 is ${project.pluginExt.nestExt.nestParam2}"
    println "nestparam3 is ${project.pluginExt.nestExt.nestParam3}"
  }
}

public class PluginImpl implements Plugin<Project> {
  void apply(Project project) {
    project.extensions.create('pluginExt', PluginExtension)
    project.pluginExt.extensions.create('nestExt', PluginNestExtension)
    project.task('customTask', type: CustomTask)
  }
}

buildscript {
  repositories {
    maven {
      url uri('../repo')
    }
  }
  dependencies {
    classpath 'cn.edu.zafu.gradle.plugin:test:1.0.0'
  }
}
apply plugin: 'plugin.test'

pluginExt {
  param1 = 'app param1'
  param2 = 'app param2'
  nestExt{
    nestParam1='app nestParam1'
    nestParam2='app nestParam2'

  }
}