const co = require("zco");
 //....

   const func = function (data0,callback){
      func1(data0,function(data1){
       func2(data1,function(data2){
          func3(data2,function(data3){
              setTimeout(function(){
                 callback(data3);
              },10);
          })
       })
    })
   }

  const func = function (data0){
     return co(function*(resume){
        let [data1] = yield func1(data0,resume);
        let [data2] = yield func2(data1,resume);
        let [data3] = yield func3(data2,resume);
        yield setTimeout(resume,10);
        return data3;
     })
  }

 func("a data")((err,data3)=>{
    if(err){
       console.log(err);
    }else{
       console.log(data3);
    }
 })

var future = func("a data");
var handler = (err,data3)=>{
    if(err){
       console.log(err);
    }else{
       console.log(data3);
    }
}
future(handler);

   co(function*(){
     let [err,data3] = yield func("a data");
     if(err){
        console.log(err);
     }else{
        console.log(data3);
     }
   })();

const a_func = function () {

  return co(function * () {

     let xxx = this.ctx.xxx; // get `xxx` from this.ctx

     return xxx;
  });

}

co(function * () {

   this.ctx.xxx = "hello world";// assign a key-value pair to `this.ctx`

   let [err,xxx] = yield a_func();// zco will deliver `this.ctx` automatically

   console.log(xxx);// "hello world"


})()

 const callback_api=function(num,callback){
    if("function" === typeof callback.ctx){
      callback(num+callback.ctx().base);
    }else{
      callback(num);
    }
 }
 co(function*(resume){
    this.ctx.base = 1;
    let [result] =  yield callback_api(10,resume);
    console.log(result);//11
 })()

co(function * (resume,defer){

   let db = null;

   defer(function *(inner_resume,err){
       if(err){
         console.log(err.message);//"Manual Error!"
       }

       db.close();

       //....or other operations you would like to do
   });

   db = database.connect();

   throw new Error("Manual Error!");

})()

    mutex.lock();//hold the lock
    //... do the request here ,and some other operations
    //... Suppose code like `JSON.parse("{")` throws an error here.
    mutex.unLock();//release the lock

  co(function*(resume,defer){

      defer(function*(){
         mutex.unLock();
      });

      mutex.lock();
      //... do the request here ,and some other operations
      //... Suppose code like `JSON.parse("{")` throws an error here.
      //But does not matter, the lock will be released safely
  })();

const async_func=function(callback){
    setTimeout(function(){
       try{
         JSON.parse("{");
       }catch(e){
         callback(e);
       }
    },10)
}
const middle_call_path=function(cb){
  return async_func(cb)
}
middle_call_path((err)=>{
  console.log(err.stack);
});

const async_func=function(){
    return co(function*(resume){
       yield setTimeout(resume,10);
       JSON.parse("{");
    });
}
const middle_call_path=function(){
    return async_func()
}
middle_call_path()((err)=>{
    console.log(err.stack);
});

const co_func=function(i){
  return co(function*(){
     return 10*i;
  })
}

co(function  * () {
	let [err1, result1] = yield co_func(1);
	if (err1) {
		throw err1;//we can throw the error ,or do something else
	}

	let [err2, result2] = yield co_func(2);
    if (err2) {
   		throw err2;
   	}

	return result1+result2;
})((err, result) => {
	if (err) {
		console.log(err);
	} else {
		console.log(result);
	}
})

//or in brief model
// just care about the result ,deal with error at end

co.brief(function*(){

   let result1 = yield co_func(1);

   let result2 = yield co_func(2);

   return result1+result2;

})((err,result)=>{
    if (err) {//deal with error at end
   		console.log(err);
   	} else {
   		console.log(result);
   	}
});

co.timeLimit(1 * 10, co(function  * (resume) {
	yield setTimeout(resume, 2 * 10);//wait 20ms,
}))((err) => {
	console.log(err.message); //"timeout"
})

const co_func = function (a, b, c) {
	return co(function  * (resume) {
	    yield setTimeout(resume,10);//wait 10ms
		return a+b+c;
	})
}

const generic_callback = function (callback) { //the first arg must be callback
	callback(100);
}

co(function  * () {
	let timeout = 10 * 1000; //timeout setting
	let[err, result] = yield co.all(co_func(1, 2, 3), co_func(4, 5, 6), generic_callback, timeout); //support set timeout，

	console.log(err); //null
	console.log(result) //[6,15,[100]]
})()

const promise_api = function (a, b) {
	return Promise.resolve().then(function () {
		return a + b;
	});
}

co(function  * () {

	let[err, data] = yield co.wrapPromise(promise_api(1, 2));
	/**
	 *  Can't yield Promise directly ,that's unsafe.Becauce some callback-style API also return a Promise at the
	 * same time,such as `pg.client.query`.
	 * */
	console.log(err); //null
	console.log(data) : //3;
})()