/*
THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
https://www.infragistics.com/legal/license/igultimate-la
https://www.infragistics.com/legal/license/igultimate-eula
GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
*/
import { Base, typeCast, Type, markType, Array_$type, Number_$type, Point_$type, enumGetBox, runOn, fromEnum } from "igniteui-react-core/ES2015/type";
import { IBucketizer_$type } from "./IBucketizer";
import { ArgumentNullException } from "igniteui-react-core/ES2015/ArgumentNullException";
import { Rect } from "igniteui-react-core/ES2015/Rect";
import { CategoryAxisBase } from "./CategoryAxisBase";
import { ISortingAxis_$type } from "./ISortingAxis";
import { ScalerParams } from "./ScalerParams";
import { Series } from "./Series";
import { truncate, intDivide, isNaN_, isInfinity } from "igniteui-react-core/ES2015/number";
import { FramePreparer } from "./FramePreparer";
import { IIsCategoryBased_$type } from "./IIsCategoryBased";
import { List$1 } from "igniteui-react-core/ES2015/List$1";
import { ISupportsMarkers_$type } from "./ISupportsMarkers";
import { IProvidesViewport_$type } from "./IProvidesViewport";
import { ISupportsErrorBars_$type } from "./ISupportsErrorBars";
import { CategoryFrame } from "./CategoryFrame";
import { PreparationParams } from "./PreparationParams";
import { IDateTimeAxis_$type } from "./IDateTimeAxis";
import { NumericAxisBase } from "./NumericAxisBase";
import { IHasCategoryTrendline_$type } from "./IHasCategoryTrendline";
import { IHasSingleValueCategory_$type } from "./IHasSingleValueCategory";
import { DefaultCategoryTrendlineHost } from "./DefaultCategoryTrendlineHost";
import { DefaultSingleValueProvider } from "./DefaultSingleValueProvider";
import { SingleValuesHolder } from "./SingleValuesHolder";
import { MarkerSeries } from "./MarkerSeries";
import { IHasCategoryModePreference_$type } from "./IHasCategoryModePreference";
import { ICategorySeriesInteractionManager_$type } from "./ICategorySeriesInteractionManager";
import { DVContainer } from "igniteui-react-core/ES2015/DVContainer";
import { DependencyProperty } from "igniteui-react-core/ES2015/DependencyProperty";
import { CategoryTransitionInMode_$type } from "./CategoryTransitionInMode";
import { HighlightingInfo } from "./HighlightingInfo";
import { CategoryTransitionSourceFramePreparer } from "./CategoryTransitionSourceFramePreparer";
import { SeriesPointOfInterest } from "./SeriesPointOfInterest";
import { Marker } from "./Marker";
import { MarkerSeriesView } from "./MarkerSeriesView";
import { CategorySeriesRenderManager } from "./CategorySeriesRenderManager";
import { Pool$1 } from "igniteui-react-core/ES2015/Pool$1";
import { Clipper } from "igniteui-react-core/ES2015/Clipper";
import { PropertyMetadata } from "igniteui-react-core/ES2015/PropertyMetadata";
import { round10N } from "igniteui-react-core/ES2015/numberExtended";
/**
 * @hidden
 */
export class CategoryBucketCalculator extends Base {
    constructor(a) {
        super();
        this.c = null;
        this.e = 0;
        this.f = 0;
        this.d = 0;
        if (a == null) {
            throw new ArgumentNullException(0, "view");
        }
        this.c = a;
        this.e = -1;
        this.d = 0;
    }
    getBucket(a) {
        return null;
    }
    getBucketWithoutUnknowns(a) {
        return this.getBucket(a);
    }
    getErrorBucket(a, b) {
        return NaN;
    }
    g(a) {
        let b = this.c.bs;
        let c = this.c.br;
        let d = this.c.cp;
        let e = typeCast(CategoryAxisBase.$, d.fetchXAxis());
        let f = d.bz;
        if (b.isEmpty || c.isEmpty || e == null || f == null || f.count == 0) {
            this.d = 0;
            return;
        }
        let g = d.getEffectiveViewport1(this.c);
        let h = d.lj(this.c);
        let i = typeCast(ISortingAxis_$type, e);
        if (i == null || i.i$b == null) {
            let j = new ScalerParams(0, b, c, e.b8, g);
            let k = Math.floor(e.dx(h.left, j, 0));
            let l = Math.ceil(e.dx(h.right, j, 0));
            if (e.b8) {
                l = Math.ceil(e.dx(h.left, j, 0));
                k = Math.floor(e.dx(h.right, j, 0));
            }
            let m = Math.floor((l - k + 1) * a / h.width);
            this.d = truncate(Math.max(1, m));
            this.e = truncate(Math.max(0, Math.floor(k / this.d) - 1));
            this.f = truncate(Math.ceil(l / this.d));
        }
        else {
            this.e = i.i$e(b, c, g, h);
            this.f = i.i$g(b, c, g, h);
            this.d = 1;
        }
    }
    getBucketInfo(a, b, c, d) {
        a = this.e;
        b = this.f;
        c = this.d;
        d = this.c.cp.er;
        return {
            p0: a,
            p1: b,
            p2: c,
            p3: d
        };
    }
    cacheValues() {
    }
    unCacheValues() {
    }
}
CategoryBucketCalculator.$t = markType(CategoryBucketCalculator, 'CategoryBucketCalculator', Base.$, [IBucketizer_$type]);
/**
 * @hidden
 */
export class CategoryFramePreparerBase extends FramePreparer {
    constructor(a, ..._rest) {
        a = (a == void 0) ? 0 : a;
        switch (a) {
            case 0:
                {
                    let c = _rest[0];
                    let d = [c, typeCast(ISupportsMarkers_$type, c), typeCast(IProvidesViewport_$type, c), typeCast(ISupportsErrorBars_$type, c), typeCast(IBucketizer_$type, c)];
                    {
                        let f = d[0];
                        let g = d[1];
                        let h = d[2];
                        let i = d[3];
                        let j = d[4];
                        super(1, g, h, i);
                        this.g = null;
                        this.h = null;
                        this.m = false;
                        this.o = new List$1(Array_$type, 0);
                        this.p = new List$1(Number_$type, 0);
                        this.n = new List$1(Number_$type, 0);
                        this.h = f;
                        this.g = j;
                    }
                }
                break;
            case 1:
                {
                    let c = _rest[0];
                    let d = _rest[1];
                    let e = _rest[2];
                    let f = _rest[3];
                    let g = _rest[4];
                    super(1, d, e, f);
                    this.g = null;
                    this.h = null;
                    this.m = false;
                    this.o = new List$1(Array_$type, 0);
                    this.p = new List$1(Number_$type, 0);
                    this.n = new List$1(Number_$type, 0);
                    this.h = c;
                    this.g = g;
                }
                break;
        }
    }
    i(a) {
        let b = new PreparationParams();
        b.f = this.h.useHighMarkerFidelity;
        b.b = this.h.scaler;
        b.c = this.h.yScaler;
        b.d = typeCast(ISortingAxis_$type, b.b);
        b.a = typeCast(CategoryFrame.$, a);
        if (b.a == null || b.b == null || b.c == null) {
            return null;
        }
        let c;
        let d;
        let e;
        let f;
        let g = this.g.getBucketInfo(c, d, e, f);
        c = g.p0;
        d = g.p1;
        e = g.p2;
        f = g.p3;
        b.i = c;
        b.j = d;
        b.h = e;
        b.g = f;
        if (b.j < b.i) {
            return null;
        }
        let h;
        let i;
        let j;
        let k = this.a.getViewInfo(i, h);
        i = k.p0;
        h = k.p1;
        j = this.a.getEffectiveViewport();
        b.m = h;
        b.l = i;
        b.k = j;
        if (Rect.l_op_Equality(b.m, Rect.empty) || Rect.l_op_Equality(b.l, Rect.empty)) {
            return null;
        }
        if (this.h != null && (typeCast(Series.$, this.h) !== null && this.h.cs) && this.g != null) {
            b.e = true;
        }
        return b;
    }
    r(a, b, c, d) {
        return a.getSeriesOffset(b, c, d, this.h.currentMode2Index, this.h.currentCategoryMode);
    }
    s(a) {
        return this.r(a.b, a.m, a.l, a.k);
    }
    d(a, b) {
        let c = this.i(a);
        if (c == null || this.g == null) {
            return;
        }
        c.a.f.clear();
        c.a.k.clear();
        c.a.m.clear();
        c.a.p.clear();
        c.a.i.clear();
        c.a.h.clear();
        c.a.g.clear();
        let d = this.c.shouldDisplayMarkers;
        let e = false;
        let f = this.s(c);
        let g = this.j(c);
        if (c.d != null && c.d.i$b != null && c.d.i$b.count != g.e) {
            return;
        }
        if (c.d != null && c.d.i$a) {
            c.d.i$h();
        }
        this.g.cacheValues();
        if (this.m && c.d != null && c.d.i$b.count > 0) {
            let h = c.d.i$b._inner[c.i];
            this.z(g, h, true, c.e);
            while ((isNaN_(g.c) || isNaN_(g.d)) && c.i > 0) {
                c.i = c.i - 1;
                h = c.d.i$b._inner[c.i];
                this.z(g, h, true, c.e);
            }
            let i = c.d.i$b._inner[c.j];
            this.z(g, i, true, c.e);
            while ((isNaN_(g.c) || isNaN_(g.d)) && c.j < g.e - 1) {
                c.j = c.j + 1;
                i = c.d.i$b._inner[c.j];
                this.z(g, i, true, c.e);
            }
        }
        if (this.m && c.d == null) {
            let j = c.i;
            let k = this.g.getBucket(j);
            while ((isNaN_(k[1]) || isNaN_(k[2])) && c.i > 0) {
                c.i = c.i - 1;
                j = c.i;
                k = this.g.getBucket(j);
            }
            let l = c.j;
            k = this.g.getBucket(l);
            while ((isNaN_(k[1]) || isNaN_(k[2])) && c.j < (intDivide(g.e, c.h))) {
                c.j = c.j + 1;
                l = c.j;
                k = this.g.getBucket(l);
            }
        }
        this.w(c, g, f);
        let m = this.t(c, g, f, d, e);
        this.c.updateMarkerCount(m);
        this.v(typeCast(CategoryFrame.$, a), b);
        this.g.unCacheValues();
        return;
    }
    v(a, b) {
    }
    get q() {
        return this.o;
    }
    t(a, b, c, d, e) {
        let f = 0;
        let g = false;
        let h = null;
        let i = false;
        let j = a.d != null;
        let k = a.m;
        let l = a.l;
        let m = typeCast(NumericAxisBase.$, a.c) !== null && a.c.jn;
        let n = a.f;
        let o = this.h.mayContainUnknowns;
        let p = this.o;
        let q = this.n;
        let r = this.p;
        p.clear();
        q.clear();
        r.clear();
        let s = this.g;
        let t = this.h.provideCollisionDetector();
        let u = 0;
        let v = a.k;
        let w = new ScalerParams(0, k, l, a.b.j$a, v);
        let x = ((() => {
            let $ret = new ScalerParams(0, k, l, a.c.j$a, v);
            $ret.b = typeCast(Series.$, this.h) !== null ? this.h.ee() : NaN;
            return $ret;
        })());
        if (j) {
            u = a.b.j$c(2, w) - a.b.j$c(1, w);
            i = this.k();
        }
        let y = a.i;
        let z = a.j;
        let aa = a.a.f;
        let ab = typeCast(IDateTimeAxis_$type, a.b);
        if (ab != null) {
            ab.StartTimeCursor();
        }
        for (let ac = y; ac <= z; ++ac) {
            let ad;
            if (!j) {
                if (!o) {
                    ad = s.getBucketWithoutUnknowns(ac);
                }
                else {
                    ad = s.getBucket(ac);
                }
            }
            else {
                ad = ((() => { let ae = this.f(a, ac, b, u, g, h, c); ac = ae.p1; g = ae.p4; h = ae.p5; return ae.ret; })());
            }
            let ae = !m || (m && ad[1] > 0);
            let af = ad[0];
            if (!j || !isNaN_(ad[0])) {
                aa.add(ad);
                if (g && i) {
                    if (h != null) {
                        aa.add(h);
                    }
                }
                if (d && ae) {
                    let ag = ac * a.h;
                    let ah = ag;
                    if (j && a.d.i$b != null && ag >= 0 && ag < a.d.i$b.count) {
                        ag = a.d.i$b._inner[ag];
                    }
                    let ai = new Array(ad.length);
                    ai[0] = ad[0];
                    ai[1] = ad[1];
                    ai[2] = ad[2];
                    if (n && ag < b.e) {
                        ai = new Array(ad.length);
                        ai[0] = af;
                        this.z(b, ag, true, a.e);
                        ai[1] = b.c;
                        ai[2] = b.d;
                    }
                    p.add(ai);
                    q.add(a.a.f.count - 1);
                    r.add(ag);
                }
            }
        }
        if (ab != null) {
            ab.ResetTimeCursor();
        }
        this.y(a, c, j, w, x, e, d);
        if (d) {
            let aj = p.count;
            let ak;
            for (let al = 0; al < aj; al++) {
                ak = p._inner[al];
                if (this.l(a.a, ak, t, Math.min(r._inner[al], b.e - 1), f, q._inner[al])) {
                    ++f;
                }
            }
        }
        return f;
    }
    k() {
        if (typeCast(Series.$, this.h) !== null) {
            return this.h.ck;
        }
        return false;
    }
    f(a, b, c, d, e, f, g) {
        let h;
        f = null;
        e = false;
        let i = typeCast(CategorySeries.$, this.h);
        let j = a.l;
        let k = a.m;
        let l = a.k;
        let m = new ScalerParams(0, k, j, a.b.j$a, l);
        let n = new ScalerParams(0, k, j, a.c.j$a, l);
        let o = a.e;
        if (a.d == null || a.d.i$b == null || a.d.i$b.count == 0) {
            return {
                ret: [NaN, NaN, NaN],
                p1: b,
                p4: e,
                p5: f
            };
        }
        if (i != null && i.bz != null && i.bz.count < a.d.i$b.count) {
            return {
                ret: [NaN, NaN, NaN],
                p1: b,
                p4: e,
                p5: f
            };
        }
        let p = a.d.i$b._inner[b];
        let q = a.d.i$d(p);
        let r = q;
        this.z(c, p, false, o);
        while (b < a.j) {
            p = a.d.i$b._inner[b + 1];
            r = a.d.i$d(p);
            this.z(c, p, true, o);
            if (r - q >= d || isNaN_(c.c) || isNaN_(c.d)) {
                if (e) {
                    let s = a.d.i$b._inner[b];
                    this.z(c, s, true, o);
                    f = [a.b.j$b(q, m), c.c, c.d];
                }
                break;
            }
            if (!e && this.k()) {
                let t = a.d.i$b._inner[b];
                this.z(c, t, true, o);
                let u = [a.b.j$b(q, m), c.c, c.d];
                if (!isNaN_(u[0])) {
                    if (!isNaN_(u[1]) && !isNaN_(u[2])) {
                        if (a.d != null) {
                            u[0] = u[0] + g;
                        }
                        a.a.f.add(u);
                        e = true;
                    }
                    else {
                        break;
                    }
                }
            }
            b++;
            this.u(c, p, o);
        }
        let v = NaN;
        if (!isNaN_(q)) {
            v = a.b.j$b(q, m);
        }
        h = this.e(v, c);
        return {
            ret: h,
            p1: b,
            p4: e,
            p5: f
        };
    }
    y(a, b, c, d, e, f, g) {
        let h = a.h;
        let i = a.a.f.count;
        let j = a.a.f;
        let k = this.o;
        let l = k.count;
        if (f) {
            let m = a.c.j$b(a.c.j7, e);
            a.c.j$e(a.a.k, 0, a.a.k.count, e);
            let n = a.a.k;
            let o = n.count;
            for (let p = 0; p < n.count; p++) {
                n._inner[p] = Math.abs(n._inner[p] - m);
            }
        }
    }
    w(a, b, c) {
    }
}
CategoryFramePreparerBase.$t = markType(CategoryFramePreparerBase, 'CategoryFramePreparerBase', FramePreparer.$);
/**
 * @hidden
 */
export class CategoryFramePreparer extends CategoryFramePreparerBase {
    constructor(a, ..._rest) {
        a = (a == void 0) ? 0 : a;
        switch (a) {
            case 0:
                {
                    let c = _rest[0];
                    let d = [c, typeCast(ISupportsMarkers_$type, c), typeCast(IProvidesViewport_$type, c), typeCast(ISupportsErrorBars_$type, c), typeCast(IBucketizer_$type, c)];
                    {
                        let f = d[0];
                        let g = d[1];
                        let h = d[2];
                        let i = d[3];
                        let j = d[4];
                        super(1, f, g, h, i, j);
                        this.aa = null;
                        this.ab = null;
                        this.aa = new DefaultCategoryTrendlineHost();
                        if (typeCast(IHasCategoryTrendline_$type, f) !== null) {
                            this.aa = typeCast(IHasCategoryTrendline_$type, f);
                        }
                        this.ab = new DefaultSingleValueProvider();
                        if (typeCast(IHasSingleValueCategory_$type, f) !== null) {
                            this.ab = typeCast(IHasSingleValueCategory_$type, f);
                        }
                    }
                }
                break;
            case 1:
                {
                    let c = _rest[0];
                    let d = _rest[1];
                    let e = _rest[2];
                    let f = _rest[3];
                    let g = _rest[4];
                    super(1, c, d, e, f, g);
                    this.aa = null;
                    this.ab = null;
                    this.aa = new DefaultCategoryTrendlineHost();
                    if (typeCast(IHasCategoryTrendline_$type, c) !== null) {
                        this.aa = typeCast(IHasCategoryTrendline_$type, c);
                    }
                    this.ab = new DefaultSingleValueProvider();
                    if (typeCast(IHasSingleValueCategory_$type, c) !== null) {
                        this.ab = typeCast(IHasSingleValueCategory_$type, c);
                    }
                }
                break;
        }
    }
    l(a, b, c, d, e, f) {
        let g = b[0];
        let h = b[1];
        let i = new Rect(0, g - 5, h - 5, 11, 11);
        if (!isNaN_(g) && !isNaN_(h) && !isInfinity(g) && !isInfinity(h) && c.tryAdd(i)) {
            a.m.add({ $type: Point_$type, x: g, y: h });
            this.c.updateMarkerTemplate(e, d, f);
            return true;
        }
        return false;
    }
    j(a) {
        let b = new SingleValuesHolder();
        let c = this.ab.valueColumn;
        b.f = c;
        return b;
    }
    x(a, b, c, d, e, f) {
        if (d) {
            b[0] = b[0] + c;
        }
        else {
            b[0] = a.b.j$b(b[0], e) + c;
        }
        b[1] = a.c.j$b(b[1], f);
        if (a.h > 1 || d) {
            b[2] = a.c.j$b(b[2], f);
        }
        else {
            b[2] = b[1];
        }
    }
    y(a, b, c, d, e, f, g) {
        super.y(a, b, c, d, e, f, g);
        let h = a.h;
        let i = a.a.f.count;
        let j = a.a.f;
        let k = this.q;
        let l = k.count;
        let m = new List$1(Number_$type, 0);
        if (!c) {
            m.add(0);
        }
        let n = new List$1(Number_$type, 0);
        n.add(1);
        if (c || h > 1) {
            n.add(2);
        }
        a.b.j$d(j, m, 0, i, d);
        a.c.j$d(j, n, 0, i, e);
        for (let o = 0; o < i; o++) {
            j._inner[o][0] = j._inner[o][0] + b;
        }
        if (h == 1 && !c) {
            for (let p = 0; p < i; p++) {
                j._inner[p][2] = j._inner[p][1];
            }
        }
        if (g) {
            a.b.j$d(k, m, 0, l, d);
            a.c.j$d(k, n, 0, l, e);
            for (let q = 0; q < l; q++) {
                k._inner[q][0] = k._inner[q][0] + b;
            }
            if (h == 1 && !c) {
                for (let r = 0; r < l; r++) {
                    k._inner[r][2] = k._inner[r][1];
                }
            }
        }
    }
    w(a, b, c) {
        if (this.aa.trendLineType == 0 || this.aa.trendlinePreparer == null || this.aa.trendLinePeriod < 1) {
            return;
        }
        this.aa.trendlinePreparer.prepareLine(this.aa, a, b, c);
    }
    z(a, b, c, d) {
        let e = a;
        let f = e.f;
        let g = f.item(b);
        let h = g;
        if (d) {
            let i = this.g.getBucket(b);
            g = i[1];
            h = i[1];
        }
        if (c) {
            e.c = g;
            e.d = h;
        }
        else {
            e.a = g;
            e.b = h;
        }
    }
    u(a, b, c) {
        let d = a;
        let e = d.f;
        if (b < e.count) {
            let f;
            if (c) {
                let g = this.g.getBucket(b);
                f = g[1];
            }
            else {
                f = e.item(b);
            }
            d.a = Math.min(d.a, f);
            d.b = Math.max(d.b, f);
        }
    }
    e(a, b) {
        let c = b;
        return [a, c.a, c.b];
    }
}
CategoryFramePreparer.$t = markType(CategoryFramePreparer, 'CategoryFramePreparer', CategoryFramePreparerBase.$);
/**
 * @hidden
 */
export class CategorySeries extends MarkerSeries {
    constructor() {
        super();
        this.m4 = null;
        this.nh = null;
        this.nl = false;
        this.nk = false;
        this.assigningCategoryStyle = null;
        this.assigningCategoryMarkerStyle = null;
        this.nf = null;
        this.ng = null;
        this.m1 = new CategoryFrame(3);
        this.m3 = new CategoryFrame(3);
        this.m0 = new CategoryFrame(3);
        this.m2 = new CategoryFrame(3);
        this.m7 = null;
        this.nb = null;
        this.m7 = new CategorySeriesRenderManager();
        this.nb = new CategoryTransitionSourceFramePreparer();
        this.nl = false;
        this.nk = false;
        this.ab = CategorySeries.$;
    }
    bf() {
        let a = new CategorySeriesView(this);
        return a;
    }
    get ni() {
        if (this.nh == null) {
            this.nh = DVContainer.instance.createInstance(ICategorySeriesInteractionManager_$type, () => this.b2.n);
        }
        return this.nh;
    }
    ch(a, b, c) {
        if (!this.hasMarkers) {
            return false;
        }
        let d = this.getEffectiveViewport1(this.bi);
        let e = this.fetchXAxis();
        let f = new ScalerParams(1, this.bs.mq, this.lr, e.b8);
        f.c = d;
        let g = this.fetchYAxis();
        let h = new ScalerParams(1, this.bs.mq, this.lr, g.b8);
        h.c = d;
        let i = this.bs.mq;
        let j = this.lr;
        let k = this.currentMode2Index;
        let l = 0;
        if (e.b5 && e.b3) {
            l = e.getSeriesOffset(i, j, d, k, e.categoryMode);
        }
        a.clear();
        this.lt.cc((m) => {
            if (m._visibility == 0) {
                let n = new SeriesPointOfInterest();
                let o = m.n;
                let p = m.o;
                if (o < this.lr.left || o > this.lr.right || p < this.lr.top || p > this.lr.bottom) {
                    return;
                }
                if (e.b2 && !e.b5 && e.categoryMode != 0) {
                    n.b = m.ak;
                }
                else {
                    n.b = e.dw(o, f);
                }
                n.c = g.dw(p, h);
                n.a = m.content;
                if (b) {
                    n.d = this.n3(n.c, c);
                }
                else {
                    n.d = e.fe(m.ak);
                }
                a.add(n);
            }
        });
        return true;
    }
    n3(a, b) {
        if (b >= 0) {
            return round10N(a, b).toString();
        }
        else {
            return a.toString();
        }
    }
    im(a) {
        super.im(a);
        this.m8 = a;
    }
    preferredCategoryMode(a) {
        return 0;
    }
    get categoryAxis() {
        return this.mz();
    }
    mz() {
        return this.fetchXAxis();
    }
    nj() {
        return this.fetchYAxis();
    }
    get_cl() {
        return true;
    }
    ac() {
        super.ac();
        this.m8.cn.g(this.er);
    }
    ns() {
        return (this.assigningCategoryStyle != null && this.nl) || this.cu;
    }
    nt() {
        return (this.assigningCategoryMarkerStyle != null && this.nk) || this.cu;
    }
    og(a) {
        if (this.assigningCategoryStyle != null && this.nl) {
            this.assigningCategoryStyle(this, a);
        }
    }
    of(a) {
        if (this.assigningCategoryMarkerStyle != null && this.nk) {
            this.assigningCategoryMarkerStyle(this, a);
        }
    }
    mt(a, b) {
        return null;
    }
    hp(a, b) {
        super.hp(a, b);
        if (a) {
            this.oa(b);
        }
    }
    a8() {
        let a = super.a8();
        return a;
    }
    h4() {
        super.h4();
        let a = this.fetchXAxis();
        if (a != null) {
            a.g0(false);
        }
        let b = this.fetchYAxis();
        if (b != null) {
            b.g0(false);
        }
    }
    jm(a, b) {
        super.jm(a, b);
        this.m8.cn.g(this.er);
        this.i6(false);
    }
    jl(a, b) {
        if (this.dl && this.ew < 0.05 && (this.bs == null || !this.bs.c5())) {
            this.dm = true;
        }
        super.jl(a, b);
        this.m8.cn.g(this.er);
        this.i6(false);
    }
    is(a, b, c, d) {
        super.is(a, b, c, d);
        switch (b) {
            case "SeriesViewer":
                let e = this.fetchYAxis();
                let f = this.fetchXAxis();
                if (c != null && d == null) {
                    this.ht(f);
                    this.ht(e);
                }
                if (c == null && d != null) {
                    this.ix(f);
                    this.ix(e);
                }
                this.m8.cn.g(this.er);
                this.i6(false);
                break;
            case "SyncLink":
                if (this.bn != null && this.bs != null) {
                    this.m8.cn.g(this.er);
                }
                this.i6(false);
                break;
            case "TransitionProgress":
                this.m3.c(this.ew, this.m1, this.m0);
                if (this.cc(this.bi)) {
                    return;
                }
                if (this.ew == 1) {
                    this.m0.v();
                    this.oh(this.m0, this.m8);
                    if (this.dl) {
                        this.dl = false;
                        this.hq();
                        this.bt.r = truncate(this.en());
                        this.bt.b = this.bu;
                    }
                }
                else {
                    this.oh(this.m3, this.m8);
                }
                if (this.bs != null) {
                    this.bs.jj(this);
                }
                break;
            case "ErrorBarSettings":
                this.ic();
                break;
            case CategorySeries.$$p[4]:
                this.i6(false);
                break;
            case CategorySeries.$$p[1]:
                this.nl = this.nn();
                this.i6(false);
                break;
            case CategorySeries.$$p[0]:
                this.nk = this.nm();
                this.i6(false);
                break;
        }
    }
    nn() {
        return this.nq;
    }
    nm() {
        return this.np;
    }
    ny(a) {
        return this.ea(a, this.fetchXAxis());
    }
    get_c1() {
        return typeCast(ISortingAxis_$type, this.mz()) !== null;
    }
    ap() {
        return this.mz();
    }
    e7(a) {
        return this.ni.b$d(this, a);
    }
    fm(a) {
        return this.ni.b$f(this, a);
    }
    e5(a) {
        let b = truncate(Math.round(this.d8(a)));
        return b;
    }
    d8(a) {
        return this.ni.b$c(this, a);
    }
    get_no() {
        return false;
    }
    get no() {
        return this.get_no();
    }
    au(a, b) {
        let c = this.ne(a, b, this.ng);
        this.ng = c;
        return c;
    }
    get_cv() {
        return true;
    }
    at(a, b) {
        if (this.no) {
            let c = this.nd(a, b, this.nf);
            this.nf = c;
            return c;
        }
        else {
            let d = this.nc(a, b, this.nf);
            this.nf = d;
            return d;
        }
    }
    nx() {
        return this.m8.cq.a;
    }
    ne(a, b, c) {
        if (!this.lw()) {
            return null;
        }
        let d = this.m0;
        if (this.ca()) {
            d = this.m3;
        }
        let e = this.nx();
        return this.ni.b$b(this, e, d.f, a, b, c);
    }
    nd(a, b, c) {
        let d = this.m8.cn.e;
        let e = this.m8.cn.f;
        let f = this.m8.cn.d;
        let g = this.m0;
        if (this.ca()) {
            g = this.m3;
        }
        return this.ni.b$a(this, g.f, d, e, f, a, b, c);
    }
    nc(a, b, c) {
        let d = new HighlightingInfo();
        d.b = this;
        d.f = 0;
        d.e = this.bz.count - 1;
        if (c != null && c.f == d.f && c.e == d.e) {
            return c;
        }
        return d;
    }
    oc(a, b, c, d, e, f) {
        let g = this.b9;
        this.m7.ab(a, b, c, d, e, f, g);
        let h = this.m7.b;
        let i = null;
        let j = this.bz;
        if (g && this.bs != null) {
            i = this.bs.az.getHighlightingInfo(this, j, d, h.m, h.l, true);
            h.b = i;
        }
        h.f = f;
        this.of(h);
        this.m7.z(i, f, g);
    }
    od(a, b, c, d, e, f) {
        let g = this.b9;
        this.m7.ac(a, b, c, d, e, f, g);
        let h = this.m7.c;
        let i = null;
        let j = this.bz;
        if (g && this.bs != null) {
            i = this.bs.az.getHighlightingInfo(this, j, d, h.m, h.l, false);
            h.b = i;
        }
        h.f = f;
        this.og(h);
        this.m7.aa(i, f, g);
    }
    dv(a, b, c) {
        let d = super.dv(a, b, c);
        d = d && this.nw(this.fetchXAxis());
        d = d && this.nw(this.fetchYAxis());
        let e = c;
        if (!c.l() || b.isEmpty || a.isEmpty || this.bz == null) {
            d = false;
        }
        if (!d) {
            e.cn.d = 0;
        }
        return d;
    }
    nw(a) {
        if (a == null || a.bf == null) {
            return false;
        }
        let b = typeCast(CategoryAxisBase.$, a);
        if (b != null) {
            if (b.itemsSource == null) {
                return false;
            }
            if (b.jr < 1) {
                return false;
            }
        }
        else {
            let c = typeCast(NumericAxisBase.$, a);
            if (c != null) {
                return c.jx != c.jw;
            }
        }
        return true;
    }
    db() {
        return this.nr;
    }
    m9() {
        return 12;
    }
    hq() {
        super.hq();
        this.m1.v();
        this.m0.v();
        this.m3.v();
    }
    i7(a) {
        super.i7(a);
        this.m8.cn.g(this.er);
        if (this.cc(this.bi)) {
            this.m0.y();
            this.m3.y();
            this.m1.y();
            return;
        }
        if (this.dd) {
            if (this.ca()) {
                if (this.bt.g) {
                    this.bt.t();
                }
                this.oh(this.m3, this.m8);
            }
            else {
                this.oh(this.m0, this.m8);
            }
            return;
        }
        if (this.c9(a)) {
            let b = this.m1;
            if (this.ca()) {
                if (this.bt.g) {
                    this.bt.t();
                }
                this.m1 = this.m3;
                this.m3 = b;
            }
            else {
                this.m1 = this.m0;
                this.m0 = b;
            }
            this.oe(this.m0, this.m8);
            if (this.dn) {
                this.bt.w();
                this.bt.r = truncate(this.eo());
                this.bt.b = this.bv != null ? this.bv : this.bu;
                this.nb.p(this.m1, this.m0, this.isVertical, this.fetchXAxis(), this.fetchYAxis(), this.na, this.m9(), this.bp, this.bo(), runOn(this, this.nz), this.m8.br);
            }
            this.hm();
            this.je();
            if (this.dn) {
                this.dm = false;
                this.dl = true;
            }
        }
        else {
            this.oe(this.m0, this.m8);
            this.oh(this.m0, this.m8);
        }
    }
    bo() {
        return 3;
    }
    nz() {
        if (this.isVertical) {
            return this.lr.left;
        }
        return this.lr.bottom;
    }
    n2() {
        let a = 0;
        let b = this.fetchXAxis();
        for (let c of fromEnum(this.bs.series)) {
            if (c == this) {
                return a;
            }
            let d = typeCast(CategorySeries.$, c);
            if (d != null) {
                let e = typeCast(CategoryAxisBase.$, d.fetchXAxis());
                if (e == b && d.preferredCategoryMode(e) == 2) {
                    a++;
                }
            }
        }
        return -1;
    }
    get GetErrorBarsXAxis() {
        return this.fetchXAxis();
    }
    get GetErrorBarsYAxis() {
        return this.fetchYAxis();
    }
    ob(a, b) {
        this.m7.w(this, this.nt(), runOn(this, this.mt), this.n0(a), this.n1(a));
        let c = this.m7.b;
        let d = c != null;
        let e = this.mz();
        if (e == null) {
            return;
        }
        let f = this.getEffectiveViewport1(a);
        let g = new ScalerParams(0, a.bs, a.br, e.b8, f);
        let h = this.bz == null ? 0 : this.bz.count;
        let i = a;
        let j = b.f;
        let k = i.cn.e;
        let l = i.cn.f;
        let m = i.cn.d;
        let n = k * m;
        for (let o = 0; o < a.cq.count; o++) {
            let p = a.cq.item(o);
            let q = p.content;
            if (d) {
                let r = p.al;
                this.oc(j, r, h, e, g, a.n);
            }
            this.m7.ad(p, q);
        }
    }
    oh(a, b) {
        this.li = a.aa;
        b.ar();
    }
    oe(a, b) {
        a.u();
    }
    n0(a) {
        return a.cn.d;
    }
    n1(a) {
        return a.cn.e;
    }
    oa(a) {
        let b = a;
        b.cq.count = 0;
    }
    i8(a, b) {
        super.i8(a, b);
        if (!this.dk) {
            this.bi.az(b);
            return;
        }
        let c = typeCast(CategorySeriesView.$, this.bh);
        c.cn.g(this.er);
        this.bi.az(b);
        if (this.cc(this.bh)) {
            return;
        }
        this.oi();
        this.dk = false;
    }
    oi() {
        let a = typeCast(CategorySeriesView.$, this.bh);
        if (!this.de) {
            this.oe(this.m2, a);
        }
        this.de = false;
        this.oh(this.m2, a);
    }
    m5(a) {
        let b = typeCast(CategorySeriesView.$, a);
        if (b != null && b.n) {
            if (b.m) {
                return new CategoryFramePreparer(1, typeCast(IIsCategoryBased_$type, this), typeCast(ISupportsMarkers_$type, b), b, this, b.cn);
            }
            else {
                return new CategoryFramePreparer(1, typeCast(IIsCategoryBased_$type, this), typeCast(ISupportsMarkers_$type, b), this.bs.bn.m, this, b.cn);
            }
        }
        else {
            return this.m4;
        }
    }
    am(a) {
        if (this.fetchXAxis() == a) {
            return this.fetchYAxis();
        }
        if (this.fetchYAxis() == a) {
            return this.fetchXAxis();
        }
        return null;
    }
    ag() {
        return [this.fetchXAxis(), this.fetchYAxis()];
    }
    static mu(a, b, c, d, e) {
        let f = null;
        if (b > -1 && !d.isEmpty && !c.isEmpty) {
            let g = a._inner[0][0] < c.left - 2000 ? c.left - 10 : NaN;
            let h = c.bottom + 10;
            let i = a._inner[b][0] > c.right + 2000 ? c.right + 10 : NaN;
            let j = c.top - 10;
            f = new Clipper(1, g, h, i, j, e);
        }
        return f;
    }
}
CategorySeries.$t = markType(CategorySeries, 'CategorySeries', MarkerSeries.$, [IHasCategoryModePreference_$type, ISupportsErrorBars_$type]);
Type.dep(DependencyProperty, PropertyMetadata, CategorySeries, 'raisePropertyChanged', ['IsCustomCategoryMarkerStyleAllowed:np:oj', [0, false], 'IsCustomCategoryStyleAllowed:nq:ok', [0, false], 'IsTransitionInEnabled:nr:ol', [0, false], 'TransitionInMode:na:om', [CategoryTransitionInMode_$type, enumGetBox(CategoryTransitionInMode_$type, 0)], 'UseHighMarkerFidelity:nv:on', [0, false]]);
/**
 * @hidden
 */
export class CategorySeriesView extends MarkerSeriesView {
    constructor(a) {
        super(a);
        this.cp = null;
        this.cs = 0;
        this.cn = null;
        this.cq = null;
        this.cs = -1;
        this.cp = a;
        this.cn = this.co();
        this.cq = ((() => {
            let $ret = new Pool$1(Marker.$);
            $ret.create = runOn(this, this.bx);
            $ret.activate = runOn(this, this.cg);
            $ret.disactivate = runOn(this, this.ci);
            $ret.destroy = runOn(this, this.ch);
            return $ret;
        })());
    }
    cr(a) {
        if (this.cs != a.t) {
            return true;
        }
        return false;
    }
    cu(a) {
        this.cs = a.t;
    }
    updateMarkerTemplate(a, b, c) {
        if (!this.by.ly) {
            let d = this.cq.item(a);
            let e = d.content;
            e.item = this.e.bz.item(b);
            d.ak = b;
            d.al = c;
        }
    }
    co() {
        return new CategoryBucketCalculator(this);
    }
    get shouldDisplayMarkers() {
        return this.cp.lw();
    }
    updateMarkerCount(a) {
        this.cq.count = a;
    }
    cc(a) {
        this.cq.c(a);
    }
    ct() {
    }
}
CategorySeriesView.$t = markType(CategorySeriesView, 'CategorySeriesView', MarkerSeriesView.$, [ISupportsMarkers_$type]);
