import chai from 'chai'
import { round, Design, Point, pctBasedOn } from '../src/index.mjs'

const expect = chai.expect

describe('Pattern', () => {

  describe('Pattern.constructor()', () => {

    it('Pattern constructor should return pattern object', () => {
      const Pattern = new Design()
      const pattern = new Pattern()
      expect(typeof pattern).to.equal('object')
    })

    it('Pattern constructor should add enumerable properties', () => {
      const Pattern = new Design()
      const pattern = new Pattern()
      expect(typeof pattern.settings).to.equal('object')
      expect(typeof pattern.config).to.equal('object')
      expect(typeof pattern.parts).to.equal('object')
      expect(typeof pattern.store).to.equal('object')
      expect(Object.keys(pattern).length).to.equal(4)
    })

    it('Pattern constructor should add non-enumerable properties', () => {
      const Pattern = new Design()
      const pattern = new Pattern()
      expect(typeof pattern.plugins).to.equal('object')
      expect(typeof pattern.autoLayout).to.equal('object')
      expect(typeof pattern.hooks).to.equal('object')
      expect(typeof pattern.Point).to.equal('function')
      expect(typeof pattern.Path).to.equal('function')
      expect(typeof pattern.Snippet).to.equal('function')
      expect(typeof pattern.Attributes).to.equal('function')
      expect(typeof pattern.macros).to.equal('object')
      expect(typeof pattern.__parts).to.equal('object')
      expect(typeof pattern.__inject).to.equal('object')
      expect(typeof pattern.__dependencies).to.equal('object')
      expect(typeof pattern.__resolvedDependencies).to.equal('object')
      expect(typeof pattern.__hide).to.equal('object')
      expect(Array.isArray(pattern.__draftOrder)).to.equal(true)
      expect(pattern.width).to.equal(0)
      expect(pattern.height).to.equal(0)
      expect(pattern.is).to.equal('')
    })

    it('Pattern constructor should add default settings', () => {
      const Pattern = new Design()
      const pattern = new Pattern()
      const dflts = {
        complete: true,
        idPrefix: 'fs-',
        locale: 'en',
        units: 'metric',
        margin: 2,
        scale: 1,
        layout: true,
        debug: false,
        options: {},
        absoluteOptions: {},
      }
      for (const [key, value] of Object.entries(dflts)) {
        if (typeof value === 'object') expect(Object.keys(value).length).to.equal(0)
        else expect(pattern.settings[key]).to.equal(value)
      }
    })

  })

  describe('Pattern.init()', () => {

    const partA = {
      name: 'test.partA',
      measurements: ['head', 'knee'],
      optionalMeasurements: [ 'chest', 'waist'],
      options: {
        optA: { pct: 40, min: 20, max: 80 }
      },
      draft: () => { }
    }
    const partB = {
      name: 'test.partB',
      measurements: ['head', 'knee'],
      optionalMeasurements: [ 'knee'],
      after: partA,
      plugins: [{
        name: 'testPlugin',
        hooks: {
          preRender: () => {}
        }
      }],
      options: {
        optB: { deg: 40, min: 20, max: 80 }
      },
      draft: () => { }
    }
    const partC = {
      name: 'test.partC',
      measurements: ['head', 'knee'],
      optionalMeasurements: [ 'knee'],
      from: partB,
      options: {
        optC: { pct: 20, min: 10, max: 30 }
      },
      draft: () => { }
    }

    const Pattern = new Design({
      data: {
        name: 'test',
        version: '1.2.3',
      },
      parts: [ partC ]
    })
    const pattern = new Pattern()
    pattern.init()

    it('Pattern.init() should resolve all measurements', () => {
      expect([
        ...pattern.config.measurements,
        ...pattern.config.optionalMeasurements
      ].length).to.equal(4)
    })

    it('Pattern.init() should resolve required measurements', () => {
      expect(pattern.config.measurements.length).to.equal(2)
      expect(pattern.config.measurements[0]).to.equal('head')
      expect(pattern.config.measurements[1]).to.equal('knee')
    })

    it('Pattern.init() should resolve optional measurements', () => {
      expect(pattern.config.optionalMeasurements.length).to.equal(2)
      expect(pattern.config.optionalMeasurements[0]).to.equal('chest')
      expect(pattern.config.optionalMeasurements[1]).to.equal('waist')
    })

    it('Pattern.init() should resolve options', () => {
      expect(Object.keys(pattern.config.options).length).to.equal(3)
      for (const [key, value] of Object.entries(partA.options.optA)) {
        expect(pattern.config.options.optA[key]).to.equal(value)
      }
      for (const [key, value] of Object.entries(partB.options.optB)) {
        expect(pattern.config.options.optB[key]).to.equal(value)
      }
      for (const [key, value] of Object.entries(partC.options.optC)) {
        expect(pattern.config.options.optC[key]).to.equal(value)
      }
    })

    it('Pattern.init() should resolve parts', () => {
      expect(pattern.config.parts.length).to.equal(3)
    })

    it('Pattern.init() should resolve plugins', () => {
      expect(pattern.config.plugins.length).to.equal(1)
    })

    it('Pattern.init() should set config data in the store', () => {
      expect(pattern.store.get('data.name')).to.equal('test')
      expect(pattern.store.get('data.version')).to.equal('1.2.3')
    })

    it('Pattern.init() should resolve dependencies', () => {
      expect(typeof pattern.config.resolvedDependencies).to.equal('object')
      expect(Array.isArray(pattern.config.resolvedDependencies['test.partA'])).to.equal(true)
      expect(pattern.config.resolvedDependencies['test.partA'].length).to.equal(0)
      expect(Array.isArray(pattern.config.resolvedDependencies['test.partB'])).to.equal(true)
      expect(pattern.config.resolvedDependencies['test.partB'].length).to.equal(1)
      expect(pattern.config.resolvedDependencies['test.partB'][0]).to.equal('test.partA')
      expect(Array.isArray(pattern.config.resolvedDependencies['test.partC'])).to.equal(true)
      expect(pattern.config.resolvedDependencies['test.partC'].length).to.equal(2)
      expect(pattern.config.resolvedDependencies['test.partC'].indexOf('test.partA') !== -1).to.equal(true)
      expect(pattern.config.resolvedDependencies['test.partC'].indexOf('test.partB') !== -1).to.equal(true)
    })

    it('Pattern.init() should resolve the draft order', () => {
      expect(Array.isArray(pattern.config.draftOrder)).to.equal(true)
      expect(pattern.config.draftOrder[0]).to.equal('test.partA')
      expect(pattern.config.draftOrder[1]).to.equal('test.partB')
      expect(pattern.config.draftOrder[2]).to.equal('test.partC')
    })

    // I am aware this does too much for one unit test, but this is to simplify TDD
    // we can split it up later
    it('Pattern.init() should resolve nested injections', () => {
      const partA = {
        name: 'partA',
        options: { optionA: { bool: true } },
        measurements: ['measieA'],
        optionalMeasurements: ['optmeasieA'],
        draft: (part) => {
          const { points, Point, paths, Path } = part.shorthand()
          points.a1 = new Point(1, 1)
          points.a2 = new Point(11, 11)
          paths.a = new Path().move(points.a1).line(points.a2)
          return part
        },
      }
      const partB = {
        name: 'partB',
        from: partA,
        options: { optionB: { pct: 12, min: 2, max: 20 } },
        measurements: ['measieB'],
        optionalMeasurements: ['optmeasieB', 'measieA'],
        draft: (part) => {
          const { points, Point, paths, Path } = part.shorthand()
          points.b1 = new Point(2, 2)
          points.b2 = new Point(22, 22)
          paths.b = new Path().move(points.b1).line(points.b2)
          return part
        },
      }
      const partC = {
        name: 'partC',
        from: partB,
        options: { optionC: { deg: 5, min: 0, max: 15 } },
        measurements: ['measieC'],
        optionalMeasurements: ['optmeasieC', 'measieA'],
        draft: (part) => {
          const { points, Point, paths, Path } = part.shorthand()
          points.c1 = new Point(3, 3)
          points.c2 = new Point(33, 33)
          paths.c = new Path().move(points.c1).line(points.c2)
          return part
        },
      }
      const partR = {
        // R for runtime, which is when this wil be attached
        name: 'partR',
        from: partA,
        after: partC,
        options: { optionR: { dflt: 'red', list: ['red', 'green', 'blue'] } },
        measurements: ['measieR'],
        optionalMeasurements: ['optmeasieR', 'measieA'],
        draft: (part) => {
          const { points, Point, paths, Path } = part.shorthand()
          points.r1 = new Point(4, 4)
          points.r2 = new Point(44, 44)
          paths.r = new Path().move(points.r1).line(points.r2)
          return part
        },
      }

      const design = new Design({ parts: [partC] })
      const pattern = new design().addPart(partR).draft()
      // Measurements
      expect(pattern.config.measurements.length).to.equal(4)
      expect(pattern.config.measurements.indexOf('measieA') === -1).to.equal(false)
      expect(pattern.config.measurements.indexOf('measieB') === -1).to.equal(false)
      expect(pattern.config.measurements.indexOf('measieC') === -1).to.equal(false)
      expect(pattern.config.measurements.indexOf('measieR') === -1).to.equal(false)
      // Optional measurements
      expect(pattern.config.optionalMeasurements.length).to.equal(4)
      expect(pattern.config.optionalMeasurements.indexOf('optmeasieA') === -1).to.equal(false)
      expect(pattern.config.optionalMeasurements.indexOf('optmeasieB') === -1).to.equal(false)
      expect(pattern.config.optionalMeasurements.indexOf('optmeasieC') === -1).to.equal(false)
      expect(pattern.config.optionalMeasurements.indexOf('optmeasieR') === -1).to.equal(false)
      expect(pattern.config.optionalMeasurements.indexOf('measieA') === -1).to.equal(true)
      // Options
      expect(pattern.config.options.optionA.bool).to.equal(true)
      expect(pattern.config.options.optionB.pct).to.equal(12)
      expect(pattern.config.options.optionB.min).to.equal(2)
      expect(pattern.config.options.optionB.max).to.equal(20)
      expect(pattern.config.options.optionC.deg).to.equal(5)
      expect(pattern.config.options.optionC.min).to.equal(0)
      expect(pattern.config.options.optionC.max).to.equal(15)
      expect(pattern.config.options.optionR.dflt).to.equal('red')
      expect(pattern.config.options.optionR.list[0]).to.equal('red')
      expect(pattern.config.options.optionR.list[1]).to.equal('green')
      expect(pattern.config.options.optionR.list[2]).to.equal('blue')
      // Dependencies
      expect(pattern.__dependencies.partB[0]).to.equal('partA')
      expect(pattern.__dependencies.partC[0]).to.equal('partB')
      expect(pattern.__dependencies.partR[0]).to.equal('partC')
      expect(pattern.__dependencies.partR[1]).to.equal('partA')
      // Inject
      expect(pattern.__inject.partB).to.equal('partA')
      expect(pattern.__inject.partC).to.equal('partB')
      expect(pattern.__inject.partR).to.equal('partA')
      // Draft order
      expect(pattern.config.draftOrder[0]).to.equal('partA')
      expect(pattern.config.draftOrder[1]).to.equal('partB')
      expect(pattern.config.draftOrder[2]).to.equal('partC')
      expect(pattern.config.draftOrder[3]).to.equal('partR')
      // Points
      expect(pattern.parts.partA.points.a1.x).to.equal(1)
      expect(pattern.parts.partA.points.a1.y).to.equal(1)
      expect(pattern.parts.partA.points.a2.x).to.equal(11)
      expect(pattern.parts.partA.points.a2.y).to.equal(11)
      expect(pattern.parts.partB.points.b1.x).to.equal(2)
      expect(pattern.parts.partB.points.b1.y).to.equal(2)
      expect(pattern.parts.partB.points.b2.x).to.equal(22)
      expect(pattern.parts.partB.points.b2.y).to.equal(22)
      expect(pattern.parts.partC.points.c1.x).to.equal(3)
      expect(pattern.parts.partC.points.c1.y).to.equal(3)
      expect(pattern.parts.partC.points.c2.x).to.equal(33)
      expect(pattern.parts.partC.points.c2.y).to.equal(33)
      expect(pattern.parts.partR.points.r1.x).to.equal(4)
      expect(pattern.parts.partR.points.r1.y).to.equal(4)
      expect(pattern.parts.partR.points.r2.x).to.equal(44)
      expect(pattern.parts.partR.points.r2.y).to.equal(44)
      // Paths in partA
      expect(pattern.parts.partA.paths.a.ops[0].to.x).to.equal(1)
      expect(pattern.parts.partA.paths.a.ops[0].to.y).to.equal(1)
      expect(pattern.parts.partA.paths.a.ops[1].to.x).to.equal(11)
      expect(pattern.parts.partA.paths.a.ops[1].to.y).to.equal(11)
      // Paths in partB
      expect(pattern.parts.partB.paths.a.ops[0].to.x).to.equal(1)
      expect(pattern.parts.partB.paths.a.ops[0].to.y).to.equal(1)
      expect(pattern.parts.partB.paths.a.ops[1].to.x).to.equal(11)
      expect(pattern.parts.partB.paths.a.ops[1].to.y).to.equal(11)
      expect(pattern.parts.partB.paths.b.ops[0].to.x).to.equal(2)
      expect(pattern.parts.partB.paths.b.ops[0].to.y).to.equal(2)
      expect(pattern.parts.partB.paths.b.ops[1].to.x).to.equal(22)
      expect(pattern.parts.partB.paths.b.ops[1].to.y).to.equal(22)
      // Paths in partC
      expect(pattern.parts.partC.paths.a.ops[0].to.x).to.equal(1)
      expect(pattern.parts.partC.paths.a.ops[0].to.y).to.equal(1)
      expect(pattern.parts.partC.paths.a.ops[1].to.x).to.equal(11)
      expect(pattern.parts.partC.paths.a.ops[1].to.y).to.equal(11)
      expect(pattern.parts.partC.paths.b.ops[0].to.x).to.equal(2)
      expect(pattern.parts.partC.paths.b.ops[0].to.y).to.equal(2)
      expect(pattern.parts.partC.paths.b.ops[1].to.x).to.equal(22)
      expect(pattern.parts.partC.paths.b.ops[1].to.y).to.equal(22)
      expect(pattern.parts.partC.paths.c.ops[0].to.x).to.equal(3)
      expect(pattern.parts.partC.paths.c.ops[0].to.y).to.equal(3)
      expect(pattern.parts.partC.paths.c.ops[1].to.x).to.equal(33)
      expect(pattern.parts.partC.paths.c.ops[1].to.y).to.equal(33)
      // Paths in partR
      expect(pattern.parts.partC.paths.a.ops[0].to.x).to.equal(1)
      expect(pattern.parts.partC.paths.a.ops[0].to.y).to.equal(1)
      expect(pattern.parts.partC.paths.a.ops[1].to.x).to.equal(11)
      expect(pattern.parts.partC.paths.a.ops[1].to.y).to.equal(11)
      expect(pattern.parts.partR.paths.r.ops[0].to.x).to.equal(4)
      expect(pattern.parts.partR.paths.r.ops[0].to.y).to.equal(4)
      expect(pattern.parts.partR.paths.r.ops[1].to.x).to.equal(44)
      expect(pattern.parts.partR.paths.r.ops[1].to.y).to.equal(44)
    })

    it('Pattern.init() should resolve nested dependencies', () => {
      const partA = {
        name: 'partA',
        options: { optionA: { bool: true } },
        measurements: ['measieA'],
        optionalMeasurements: ['optmeasieA'],
        draft: (part) => {
          const { points, Point, paths, Path } = part.shorthand()
          points.a1 = new Point(1, 1)
          points.a2 = new Point(11, 11)
          paths.a = new Path().move(points.a1).line(points.a2)
          return part
        },
      }
      const partB = {
        name: 'partB',
        from: partA,
        options: { optionB: { pct: 12, min: 2, max: 20 } },
        measurements: ['measieB'],
        optionalMeasurements: ['optmeasieB', 'measieA'],
        draft: (part) => {
          const { points, Point, paths, Path } = part.shorthand()
          points.b1 = new Point(2, 2)
          points.b2 = new Point(22, 22)
          paths.b = new Path().move(points.b1).line(points.b2)
          return part
        },
      }
      const partC = {
        name: 'partC',
        from: partB,
        options: { optionC: { deg: 5, min: 0, max: 15 } },
        measurements: ['measieC'],
        optionalMeasurements: ['optmeasieC', 'measieA'],
        draft: (part) => {
          const { points, Point, paths, Path } = part.shorthand()
          points.c1 = new Point(3, 3)
          points.c2 = new Point(33, 33)
          paths.c = new Path().move(points.c1).line(points.c2)
          return part
        },
      }
      const partD = {
        name: 'partD',
        after: partC,
        options: { optionD: { dflt: 'red', list: ['red', 'green', 'blue'] } },
        measurements: ['measieD'],
        optionalMeasurements: ['optmeasieD', 'measieA'],
        draft: (part) => {
          const { points, Point, paths, Path } = part.shorthand()
          points.d1 = new Point(4, 4)
          points.d2 = new Point(44, 44)
          paths.d = new Path().move(points.d1).line(points.d2)
          return part
        },
      }
      const design = new Design({ parts: [partD] })
      const pattern = new design().draft()
      // Measurements
      expect(pattern.config.measurements.length).to.equal(4)
      expect(pattern.config.measurements.indexOf('measieA') === -1).to.equal(false)
      expect(pattern.config.measurements.indexOf('measieB') === -1).to.equal(false)
      expect(pattern.config.measurements.indexOf('measieC') === -1).to.equal(false)
      expect(pattern.config.measurements.indexOf('measieD') === -1).to.equal(false)
      // Optional measurements
      expect(pattern.config.optionalMeasurements.length).to.equal(4)
      expect(pattern.config.optionalMeasurements.indexOf('optmeasieA') === -1).to.equal(false)
      expect(pattern.config.optionalMeasurements.indexOf('optmeasieB') === -1).to.equal(false)
      expect(pattern.config.optionalMeasurements.indexOf('optmeasieC') === -1).to.equal(false)
      expect(pattern.config.optionalMeasurements.indexOf('optmeasieD') === -1).to.equal(false)
      expect(pattern.config.optionalMeasurements.indexOf('measieA') === -1).to.equal(true)
      // Options
      expect(pattern.config.options.optionA.bool).to.equal(true)
      expect(pattern.config.options.optionB.pct).to.equal(12)
      expect(pattern.config.options.optionB.min).to.equal(2)
      expect(pattern.config.options.optionB.max).to.equal(20)
      expect(pattern.config.options.optionC.deg).to.equal(5)
      expect(pattern.config.options.optionC.min).to.equal(0)
      expect(pattern.config.options.optionC.max).to.equal(15)
      expect(pattern.config.options.optionD.dflt).to.equal('red')
      expect(pattern.config.options.optionD.list[0]).to.equal('red')
      expect(pattern.config.options.optionD.list[1]).to.equal('green')
      expect(pattern.config.options.optionD.list[2]).to.equal('blue')
      // Dependencies
      expect(pattern.__dependencies.partB[0]).to.equal('partA')
      expect(pattern.__dependencies.partC[0]).to.equal('partB')
      expect(pattern.__dependencies.partD[0]).to.equal('partC')
      // Inject
      expect(pattern.__inject.partB).to.equal('partA')
      expect(pattern.__inject.partC).to.equal('partB')
      // Draft order
      expect(pattern.config.draftOrder[0]).to.equal('partA')
      expect(pattern.config.draftOrder[1]).to.equal('partB')
      expect(pattern.config.draftOrder[2]).to.equal('partC')
      expect(pattern.config.draftOrder[3]).to.equal('partD')
      // Points
      expect(pattern.parts.partA.points.a1.x).to.equal(1)
      expect(pattern.parts.partA.points.a1.y).to.equal(1)
      expect(pattern.parts.partA.points.a2.x).to.equal(11)
      expect(pattern.parts.partA.points.a2.y).to.equal(11)
      expect(pattern.parts.partB.points.b1.x).to.equal(2)
      expect(pattern.parts.partB.points.b1.y).to.equal(2)
      expect(pattern.parts.partB.points.b2.x).to.equal(22)
      expect(pattern.parts.partB.points.b2.y).to.equal(22)
      expect(pattern.parts.partC.points.c1.x).to.equal(3)
      expect(pattern.parts.partC.points.c1.y).to.equal(3)
      expect(pattern.parts.partC.points.c2.x).to.equal(33)
      expect(pattern.parts.partC.points.c2.y).to.equal(33)
      expect(pattern.parts.partD.points.d1.x).to.equal(4)
      expect(pattern.parts.partD.points.d1.y).to.equal(4)
      expect(pattern.parts.partD.points.d2.x).to.equal(44)
      expect(pattern.parts.partD.points.d2.y).to.equal(44)
      // Paths in partA
      expect(pattern.parts.partA.paths.a.ops[0].to.x).to.equal(1)
      expect(pattern.parts.partA.paths.a.ops[0].to.y).to.equal(1)
      expect(pattern.parts.partA.paths.a.ops[1].to.x).to.equal(11)
      expect(pattern.parts.partA.paths.a.ops[1].to.y).to.equal(11)
      // Paths in partB
      expect(pattern.parts.partB.paths.a.ops[0].to.x).to.equal(1)
      expect(pattern.parts.partB.paths.a.ops[0].to.y).to.equal(1)
      expect(pattern.parts.partB.paths.a.ops[1].to.x).to.equal(11)
      expect(pattern.parts.partB.paths.a.ops[1].to.y).to.equal(11)
      expect(pattern.parts.partB.paths.b.ops[0].to.x).to.equal(2)
      expect(pattern.parts.partB.paths.b.ops[0].to.y).to.equal(2)
      expect(pattern.parts.partB.paths.b.ops[1].to.x).to.equal(22)
      expect(pattern.parts.partB.paths.b.ops[1].to.y).to.equal(22)
      // Paths in partC
      expect(pattern.parts.partC.paths.a.ops[0].to.x).to.equal(1)
      expect(pattern.parts.partC.paths.a.ops[0].to.y).to.equal(1)
      expect(pattern.parts.partC.paths.a.ops[1].to.x).to.equal(11)
      expect(pattern.parts.partC.paths.a.ops[1].to.y).to.equal(11)
      expect(pattern.parts.partC.paths.b.ops[0].to.x).to.equal(2)
      expect(pattern.parts.partC.paths.b.ops[0].to.y).to.equal(2)
      expect(pattern.parts.partC.paths.b.ops[1].to.x).to.equal(22)
      expect(pattern.parts.partC.paths.b.ops[1].to.y).to.equal(22)
      expect(pattern.parts.partC.paths.c.ops[0].to.x).to.equal(3)
      expect(pattern.parts.partC.paths.c.ops[0].to.y).to.equal(3)
      expect(pattern.parts.partC.paths.c.ops[1].to.x).to.equal(33)
      expect(pattern.parts.partC.paths.c.ops[1].to.y).to.equal(33)
      // Paths in partR
      expect(pattern.parts.partD.paths.d.ops[0].to.x).to.equal(4)
      expect(pattern.parts.partD.paths.d.ops[0].to.y).to.equal(4)
      expect(pattern.parts.partD.paths.d.ops[1].to.x).to.equal(44)
      expect(pattern.parts.partD.paths.d.ops[1].to.y).to.equal(44)
    })

    it('Pattern.init() should load a single plugin', () => {
      const plugin = {
        name: 'example',
        version: 1,
        hooks: {
          preRender: function (svg, attributes) {
            svg.attributes.add('freesewing:plugin-example', version)
          },
        },
      }
      const part = {
        name: 'test.part',
        plugins: plugin,
        draft: (part) => part,
      }
      const design = new Design({ parts: [part] })
      const pattern = new design()
      pattern.init()
      expect(pattern.hooks.preRender.length).to.equal(1)
    })

    it("Pattern.init() should load array of plugins", () => {
      const plugin1 = {
        name: "example1",
        version: 1,
        hooks: {
          preRender: function(svg, attributes) {
            svg.attributes.add("freesewing:plugin-example1", version);
          }
        }
      };
      const plugin2 = {
        name: "example2",
        version: 2,
        hooks: {
          preRender: function(svg, attributes) {
            svg.attributes.add("freesewing:plugin-example2", version);
          }
        }
      };

      const design = new Design( { plugins: [plugin1, plugin2] });
      const pattern = new design();
      pattern.init()
      expect(pattern.hooks.preRender.length).to.equal(2);
    });
    it("Pattern.init() should load conditional plugin", () => {
      const plugin = {
        name: "example",
        version: 1,
        hooks: {
          preRender: function(svg, attributes) {
            svg.attributes.add("freesewing:plugin-example", version);
          }
        }
      };
      const condition = () => true
      const design = new Design({ plugins: [ { plugin, condition } ] });
      const pattern = new design();
      pattern.init()
      expect(pattern.hooks.preRender.length).to.equal(1);
    });

    it("Pattern.init() should not load conditional plugin", () => {
      const plugin = {
        name: "example",
        version: 1,
        hooks: {
          preRender: function(svg, attributes) {
            svg.attributes.add("freesewing:plugin-example", version);
          }
        }
      };
      const condition = () => false
      const design = new Design({ plugins: { plugin, condition } });
      const pattern = new design();
      expect(pattern.hooks.preRender.length).to.equal(0);
    });

    it("Pattern.init() should load multiple conditional plugins", () => {
      const plugin = {
        name: "example",
        version: 1,
        hooks: {
          preRender: function(svg, attributes) {
            svg.attributes.add("freesewing:plugin-example", version);
          }
        }
      };
      const condition1 = () => true
      const condition2 = () => false
      const design = new Design({ plugins:  [
        { plugin, condition: condition1 },
        { plugin, condition: condition2 },
      ]});
      const pattern = new design();
      pattern.init()
      expect(pattern.hooks.preRender.length).to.equal(1);
    })
  })

  describe('Pattern.settings', () => {

    const part = {
      name: 'test.part',
      options: {
        pct: { pct: 30, min: 10, max: 50 },
        altpct: { pct: 30, min: 10, max: 50 },
        mm: { mm: 12, min: 4, max: 23 },
        deg: { deg: 2, min: 1, max: 3 },
        list: {
          dflt: 'd',
          choices: ['a', 'b' ,'c', 'd']
        },
        count: { count: 4, min: 1, max: 13 },
        bool: { bool: false },
      },
      draft: () => { }
    }
    const Pattern = new Design({
      data: {
        name: 'test',
        version: '1.2.3',
      },
      parts: [ part ]
    })
    const pattern = new Pattern()
    pattern.init()

    it('Pattern settings should contain percentage options', () => {
      expect(pattern.settings.options.pct).to.equal(0.3)
    })

    it('Pattern settings should contain millimeter options', () => {
      expect(pattern.settings.options.mm).to.equal(12)
    })

    it('Pattern settings should contain degree options', () => {
      expect(pattern.settings.options.deg).to.equal(2)
    })

    it('Pattern settings should contain list options', () => {
      expect(pattern.settings.options.list).to.equal('d')
    })

    it('Pattern settings should contain count options', () => {
      expect(pattern.settings.options.count).to.equal(4)
    })

    it('Pattern settings should contain bool options', () => {
      expect(pattern.settings.options.bool).to.equal(false)
    })

    it('Pattern should throw an error for an unknown option', () => {
      const part = {
        name: 'test.part',
        options: { unknown: { foo: 30 } },
        draft: () => { }
      }
      const Pattern = new Design({
        data: { name: 'test', version: '1.2.3' },
        parts: [ part ]
      })
      const pattern = new Pattern()
      expect(() => pattern.init()).to.throw()
    })

  })


})