// d3.js example

var svg = {}
svg.line = function() {
  var getX = function() {}
  var getY = function() {}
  var interpolate = function() {}

  function line(data) {
    //...
    // private 함수.
    function segment() {}
    var d = data
    // getX 와 getY 로 필요한 데이터를 추출해서 사용.
    // call 로 함수를 호출 하는 까닭은~?
    getX.call(this, d, i)
    getY.call(this, d, i)

    // 추출 후 segment() 함수 사용.
  }

  line.x = function(fn) {
    if (!argument.length) return getX
    getX = fn
    return line
  }
  line.y = function(fn) {
    if (!argument.length) return getY
    getY = fn
    return line
  }

  return line // 함수를 리턴한다.
}

// usage
var lineGenerator = svg.line()
var path = lineGenerator(data)

// 데이터가 달라질때 데이터 추출을 위한 함수 변경이 필요하다.
var lineGenerator = svg
  .line()
  .x(function(d) {})
  .y(function(d) {})

// 내가 만든 객체에서 값을 얻게끔 라인 생성기를 확장.
var merlin = {
  getValue: function() {},
  lineGenerator: svg
    .line()
    .x(function(d) {
      return 10 - this.getValue()
    })
    .y(function(d) {
      return 10 + this.getValue()
    }),
}

var path = merlin.lineGenerator()

 // 오리라면 먹이를 주자. 이런 주제가 있다고 하면
 // 오리
 function Duck(){
     return {
         duckSound: function(){}
     }
 }

 // 어떤새.
 function Bird(){
     return {
         duckSound: function(){}
     }
 }

 function Merlin(){
     return {
         feed: function(obj){
             // if( obj instanceof Duck ) // 이것은 Duck로 객체를 생성했을 시.
             // if('duckSound' in obj)
             if(obj.hasOwnProperty('duckSound')){ // 이부분 오리인지 아닌지 확인하는 부분
                 return true;
             }
             return false;
         }
     }
 }
 var bird1 = new Bird();
 var bird2 = new Duck();
 var merlin = new Merlin();

 var result1 = merlin.feed(bird1); // true
 var result2 = merlin.feed(bird2); // true

 // 판별 방법
 if( something instanceof Merlin)
 // or
 if( 'x' in something)
 // or
 if( something.hasOwnProperty('x'))

// ex 1) 인자 갯수에 따른 다른 처리 방법
function a() {
  if (!arguments.length) {
    // 인자가 하나도 없을 시 처리하는 로직
    return
  }

  // 그외..
}

// ex 2) 콜백함수

function a(data, fn) {
  var i = 0
  var d = data

  while (i < 10) {
    fn(data, i)
    i++
  }
}
// a에 넘기는 콜백함수는 기본 인자를 2개 받기에 사용자가 선택적으로 사용해도 된다.
a({}, function(data, index) {
  // data 만 써두 되고..
  // 주는 index를 같이 써두 되고..
  // 사용자에게 선택의 폭을 넓혀준다.
})

// bad!!
function A() {
  var b = new B() // b 에 의존.
  return {
    //..
  }
}

function B() {
  var name = 'merlin'
  return {
    id: name,
  }
}

// good!!
function A() {
  var b = { id: 'none' } // 인터페이스

  return {
    setB: function(obj) {
      b = obj
    },
  }
}

var a = new A()
a.setB(new B())

// 어떠한 데이터로 라인을 그린다.
function baseFn(data) {
  return data
}

svg.line = function() {
  return svg_line(baseFn)
}

function svg_line(projection) {
  function line(data) {
    function segment() {
      // 이 함수를 호출해서 여러가지 일을 한다...
      projection(data)
    }
  }
  return line
}

var lineGenerator = svg.line()
var path = lineGenerator(data) // 이렇게 하면 데이터 그대로 라인을 그린다.

// 허나 난 이 데이터를 기반으로 다른 모양으로 그리겠다.
// 데이터를 어떻게 조작할지만 생각한다. 즉, baseFn 만 바꿔주면된다.

function additionFn(data) {
  return data * 0.3
}
svg.line.addition = function() {
  return svg_line(additionFn) // 의존성 주입.
}
var lineGenerator = svg.line.addition()
var path = lineGenerator(data)

// bad
while (++i < n) {
  points.push([+getX.call(this, data[i], i), +getY.call(this, data[i], i)])
}

// good
var d
while (++i < n) {
  d = data[i]
  points.push([+getX.call(this, d, i), +getY.call(this, d, i)])
}

TravelService = (function(rawWebService) {
  var conferenceAirport = 'BOS'
  var maxArrival = new Date()
  var minDeparture = new Date()

  // 간단한 캐싱: 인덱스는 공항이고 객체는 티켓이다.
  var cache = []

  return {
    getSuggestedTicket: function(homeAirport) {
      var ticket
      if (cache[homeAirport]) {
        return cache[homeAirport]
      }

      ticket = rawWebService.getCheapesRoundTrip(
        homeAirport,
        conferenceAirport,
        maxArrival,
        minDeparture
      )

      cache[homeAirport] = ticket

      return ticket
    },
  }
})()

Aop.around('getSuggestedTicket', cacheAspectFactory())

Aop = {
  around: function(fnName, advice, fnObj) {
    var originalFn = fnObj[fnName]
    fnObj[fnName] = function() {
      return advice.call(this, { fn: originalFn, args: arguments })
    }
  },

  next: function(targetInfo) {
    return targetInfo.fn.apply(this, targetInfo.args)
  },
}

Aop.before = function(fnName, advice, fnObj) {
  Aop.around(
    fnName,
    function(targetInfo) {
      advice.apply(this, targetInfo.args)
      return Aop.next(targetInfo)
    },
    fnObj
  )
}

Aop.after = function(fnName, advice, fnObj) {
  Aop.around(
    fnName,
    function(targetInfo) {
      var ret = Aop.next(targetInfo)
      advice.apply(this, targetInfo.args)
      return ret
    },
    fnObj
  )
}