// Copyright 2021, Chef.  All rights reserved.
// https://github.com/q191201771/lal
//
// Use of this source code is governed by a MIT-style license
// that can be found in the License file.
//
// Author: Chef (191201771@qq.com)

package avc

import (
	"encoding/hex"

	"github.com/q191201771/naza/pkg/nazaerrors"

	"github.com/q191201771/naza/pkg/bele"
	"github.com/q191201771/naza/pkg/nazabits"
	"github.com/q191201771/naza/pkg/nazabytes"
	"github.com/q191201771/naza/pkg/nazalog"
)

func ParseSps(payload []byte, ctx *Context) error {
	br := nazabits.NewBitReader(payload)
	var sps Sps
	if err := parseSpsBasic(&br, &sps); err != nil {
		nazalog.Errorf("parseSpsBasic failed. err=%+v, payload=%s", err, hex.Dump(nazabytes.Prefix(payload, 128)))
		return err
	}
	ctx.Profile = sps.ProfileIdc
	ctx.Level = sps.LevelIdc

	//if err := parseSpsBeta(&br, &sps); err != nil {
	//	// 注意，这里不将错误返回给上层，因为可能是Beta自身解析的问题
	//}

	if err := parseSpsGamma(&br, &sps); err != nil {
		// 注意，这里不将错误返回给上层，因为可能是Beta自身解析的问题
		nazalog.Errorf("parseSpsGamma failed. err=%+v, payload=%s", err, hex.Dump(nazabytes.Prefix(payload, 128)))
	}
	nazalog.Debugf("sps=%+v", sps)

	ctx.Width = (sps.PicWidthInMbsMinusOne+1)*16 - (sps.FrameCropLeftOffset+sps.FrameCropRightOffset)*2
	ctx.Height = (2-uint32(sps.FrameMbsOnlyFlag))*(sps.PicHeightInMapUnitsMinusOne+1)*16 - (sps.FrameCropTopOffset+sps.FrameCropBottomOffset)*2
	return nil
}

// 尝试解析PPS所有字段，实验中，请勿直接使用该函数
func TryParsePps(payload []byte) error {
	// ISO-14496-10.pdf
	// 7.3.2.2 Picture parameter set RBSP syntax

	// TODO impl me
	return nil
}

// 尝试解析SeqHeader所有字段，实验中，请勿直接使用该函数
//
// @param <payload> rtmp message的payload部分或者flv tag的payload部分
//                  注意，包含了头部2字节类型以及3字节的cts
//
func TryParseSeqHeader(payload []byte) error {
	if len(payload) < 5 {
		return ErrAvc
	}
	if payload[0] != 0x17 || payload[1] != 0x00 || payload[2] != 0 || payload[3] != 0 || payload[4] != 0 {
		return ErrAvc
	}

	// H.264-AVC-ISO_IEC_14496-15.pdf
	// 5.2.4 Decoder configuration information
	var dcr DecoderConfigurationRecord
	var err error
	br := nazabits.NewBitReader(payload[5:])

	// TODO check error
	dcr.ConfigurationVersion, err = br.ReadBits8(8)
	dcr.AvcProfileIndication, err = br.ReadBits8(8)
	dcr.ProfileCompatibility, err = br.ReadBits8(8)
	dcr.AvcLevelIndication, err = br.ReadBits8(8)
	_, err = br.ReadBits8(6) // reserved = '111111'b
	dcr.LengthSizeMinusOne, err = br.ReadBits8(2)

	_, err = br.ReadBits8(3) // reserved = '111'b
	dcr.NumOfSps, err = br.ReadBits8(5)
	b, err := br.ReadBytes(2)
	dcr.SpsLength = bele.BeUint16(b)

	_, _ = br.ReadBytes(uint(dcr.SpsLength))

	_, err = br.ReadBits8(3) // reserved = '111'b
	dcr.NumOfPps, err = br.ReadBits8(5)
	b, err = br.ReadBytes(2)
	dcr.PpsLength = bele.BeUint16(b)

	nazalog.Debugf("%+v", dcr)

	// 5 + 5 + 1 + 2
	var ctx Context
	_ = ParseSps(payload[13:13+dcr.SpsLength], &ctx)
	// 13 + 1 + 2
	_ = TryParsePps(payload[16 : 16+dcr.PpsLength])

	return err
}

func parseSpsBasic(br *nazabits.BitReader, sps *Sps) error {
	t, err := br.ReadBits8(8) //nalType SPS should be 0x67
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	_ = t
	//if t != 0x67 {
	//	return Context{}, ErrAvc
	//}

	sps.ProfileIdc, err = br.ReadBits8(8)
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	sps.ConstraintSet0Flag, err = br.ReadBits8(1)
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	sps.ConstraintSet1Flag, err = br.ReadBits8(1)
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	sps.ConstraintSet2Flag, err = br.ReadBits8(1)
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	_, err = br.ReadBits8(5)
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	sps.LevelIdc, err = br.ReadBits8(8)
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	sps.SpsId, err = br.ReadGolomb()
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	if sps.SpsId >= 32 {
		return nazaerrors.Wrap(ErrAvc)
	}
	return nil
}

func parseSpsGamma(br *nazabits.BitReader, sps *Sps) (err error) {
	switch sps.ProfileIdc {
	case 100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 139, 134:
		sps.ChromaFormatIdc, err = br.ReadUeGolomb() // chroma_format_idc
		if err != nil {
			return nazaerrors.Wrap(err)
		}
		if sps.ChromaFormatIdc == 3 {
			sps.ResidualColorTransformFlag, err = br.ReadBits8(1) // separate_colour_plane_flag
			if err != nil {
				return nazaerrors.Wrap(err)
			}
		}
		sps.BitDepthLuma, err = br.ReadUeGolomb()
		if err != nil {
			return nazaerrors.Wrap(err)
		}
		sps.BitDepthLuma += 8

		sps.BitDepthChroma, err = br.ReadUeGolomb()
		if err != nil {
			return nazaerrors.Wrap(err)
		}
		sps.BitDepthChroma += 8

		sps.TransFormBypass, err = br.ReadBits8(1) // qpprime_y_zero_transform_bypass_flag
		if err != nil {
			return nazaerrors.Wrap(err)
		}

		flag, err := br.ReadBits8(1) // seq_scaling_matrix_present_flag
		if err != nil {
			return nazaerrors.Wrap(err)
		}
		if flag == 1 {
			loop := 8
			if sps.ChromaFormatIdc == 3 {
				loop = 12
			}
			deltaScale := 0
			lastScale := 8
			nextScale := 8
			for i := 0; i < loop; i++ {
				flag, err := br.ReadBits8(1) // seq_scaling_list_present_flag
				if err != nil {
					return nazaerrors.Wrap(err)
				}
				if flag == 0 {
					continue
				}
				lastScale = 8
				nextScale = 8
				sizeOfScalingList := 16
				if i >= 6 {
					sizeOfScalingList = 64
				}
				for j := 0; j < sizeOfScalingList; j++ {
					if nextScale != 0 {
						v, err := br.ReadSeGolomb()
						if err != nil {
							return nazaerrors.Wrap(err)
						}
						deltaScale = int(v)
						nextScale = (lastScale + deltaScale) & 0xff
					}
					if nextScale != 0 {
						lastScale = nextScale
					}
				}
			}
		}
	default:
		sps.ChromaFormatIdc = 1
		sps.BitDepthLuma = 8
		sps.BitDepthChroma = 8
	}

	sps.Log2MaxFrameNumMinus4, err = br.ReadUeGolomb() // log2_max_frame_num_minus4
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	sps.PicOrderCntType, err = br.ReadUeGolomb()
	if err != nil {
		return nazaerrors.Wrap(err)
	}

	if sps.PicOrderCntType == 0 {
		sps.Log2MaxPicOrderCntLsb, err = br.ReadUeGolomb() // log2_max_pic_order_cnt_lsb_minus4
		if err != nil {
			return nazaerrors.Wrap(err)
		}
		sps.Log2MaxPicOrderCntLsb += 4
	} else if sps.PicOrderCntType == 1 {
		_, _ = br.ReadBits8(1)   // delta_pic_order_always_zero
		_, _ = br.ReadSeGolomb() // offset_for_non_ref_pic
		_, _ = br.ReadSeGolomb() // offset_for_top_to_bottom_field
		if br.Err() != nil {
			return nazaerrors.Wrap(err)
		}
		nrfipocc, err := br.ReadUeGolomb() // num_ref_frames_in_pic_order_cnt_cycle
		if err != nil {
			return nazaerrors.Wrap(err)
		}
		for i := 0; i < int(nrfipocc); i++ {
			_, err := br.ReadSeGolomb() // offset_for_ref_frame
			if err != nil {
				return nazaerrors.Wrap(err)
			}
		}
	}

	sps.NumRefFrames, _ = br.ReadUeGolomb()                 // max_num_ref_frames
	sps.GapsInFrameNumValueAllowedFlag, _ = br.ReadBits8(1) // gaps_in_frame_num_value_allowed_flag
	sps.PicWidthInMbsMinusOne, _ = br.ReadUeGolomb()        // pic_width_in_mbs_minus1
	sps.PicHeightInMapUnitsMinusOne, _ = br.ReadUeGolomb()  // pic_height_in_map_units_minus1
	if br.Err() != nil {
		return nazaerrors.Wrap(err)
	}

	sps.FrameMbsOnlyFlag, err = br.ReadBits8(1)
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	if sps.FrameMbsOnlyFlag == 0 {
		sps.MbAdaptiveFrameFieldFlag, err = br.ReadBits8(1) // mb_adaptive_frame_field_flag
		if err != nil {
			return nazaerrors.Wrap(err)
		}
	}

	sps.Direct8X8InferenceFlag, err = br.ReadBits8(1) // direct_8x8_inference_flag
	if err != nil {
		return nazaerrors.Wrap(err)
	}

	sps.FrameCroppingFlag, err = br.ReadBits8(1)
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	if sps.FrameCroppingFlag == 1 { // frame_cropping_flag
		sps.FrameCropLeftOffset, _ = br.ReadUeGolomb()   // frame_crop_left_offset
		sps.FrameCropRightOffset, _ = br.ReadUeGolomb()  // frame_crop_right_offset
		sps.FrameCropTopOffset, _ = br.ReadUeGolomb()    // frame_crop_top_offset
		sps.FrameCropBottomOffset, _ = br.ReadUeGolomb() // frame_crop_bottom_offset
		if br.Err() != nil {
			return nazaerrors.Wrap(err)
		}
	}

	flag, err := br.ReadBits8(1) // vui_parameters_present_flag
	if err != nil {
		return nazaerrors.Wrap(err)
	}
	if flag == 1 {
		flag, err := br.ReadBits8(1) // aspect_ratio_info_present_flag
		if err != nil {
			return nazaerrors.Wrap(err)
		}
		if flag == 1 {
			ari, err := br.ReadBits8(8) // aspect_ratio_idc
			if err != nil {
				return nazaerrors.Wrap(err)
			}
			if ari == 0xff {
				v, err := br.ReadBits16(16)
				if err != nil {
					return nazaerrors.Wrap(err)
				}
				sps.SarNum = int(v)
				v, err = br.ReadBits16(16)
				if err != nil {
					return nazaerrors.Wrap(err)
				}
				sps.SarDen = int(v)
			} else if ari < 17 {
				mapping := []struct {
					num int
					den int
				}{
					{0, 1},
					{1, 1},
					{12, 11},
					{10, 11},
					{16, 11},
					{40, 33},
					{24, 11},
					{20, 11},
					{32, 11},
					{80, 33},
					{18, 11},
					{15, 11},
					{64, 33},
					{160, 99},
					{4, 3},
					{3, 2},
					{2, 1},
				}
				sps.SarNum = mapping[ari].num
				sps.SarDen = mapping[ari].den
			}
		}
	}

	if sps.SarDen == 0 {
		sps.SarNum = 1
		sps.SarDen = 1
	}

	return nil
}

//func parseSpsBeta(br *nazabits.BitReader, sps *Sps) error {
//	var err error
//
//	// 100 High profile
//	if sps.ProfileIdc == 100 {
//		sps.ChromaFormatIdc, err = br.ReadUeGolomb()
//		if err != nil {
//			return nazaerrors.Wrap(err)
//		}
//		if sps.ChromaFormatIdc > 3 {
//			return nazaerrors.Wrap(ErrAvc)
//		}
//
//		if sps.ChromaFormatIdc == 3 {
//			sps.ResidualColorTransformFlag, err = br.ReadBits8(1)
//			if err != nil {
//				return nazaerrors.Wrap(err)
//			}
//		}
//
//		sps.BitDepthLuma, err = br.ReadUeGolomb()
//		if err != nil {
//			return nazaerrors.Wrap(err)
//		}
//		sps.BitDepthLuma += 8
//
//		sps.BitDepthChroma, err = br.ReadUeGolomb()
//		if err != nil {
//			return nazaerrors.Wrap(err)
//		}
//		sps.BitDepthChroma += 8
//
//		if sps.BitDepthChroma != sps.BitDepthLuma || sps.BitDepthChroma < 8 || sps.BitDepthChroma > 14 {
//			return nazaerrors.Wrap(ErrAvc)
//		}
//
//		sps.TransFormBypass, err = br.ReadBits8(1)
//		if err != nil {
//			return nazaerrors.Wrap(err)
//		}
//
//		// seq scaling matrix present
//		flag, err := br.ReadBits8(1)
//		if err != nil {
//			return nazaerrors.Wrap(err)
//		}
//		if flag == 1 {
//			nazalog.Debugf("scaling matrix present.")
//			// TODO chef: 还没有正确实现，只是针对特定case做了处理
//			_, err = br.ReadBits32(128)
//			if err != nil {
//				return nazaerrors.Wrap(err)
//			}
//		}
//	} else {
//		sps.ChromaFormatIdc = 1
//		sps.BitDepthLuma = 8
//		sps.BitDepthChroma = 8
//	}
//
//	sps.Log2MaxFrameNumMinus4, err = br.ReadUeGolomb()
//	if err != nil {
//		return nazaerrors.Wrap(err)
//	}
//	if sps.Log2MaxFrameNumMinus4 > 12 {
//		return nazaerrors.Wrap(ErrAvc)
//	}
//	sps.PicOrderCntType, err = br.ReadUeGolomb()
//	if err != nil {
//		return nazaerrors.Wrap(err)
//	}
//
//	if sps.PicOrderCntType == 0 {
//		sps.Log2MaxPicOrderCntLsb, err = br.ReadUeGolomb()
//		sps.Log2MaxPicOrderCntLsb += 4
//	} else if sps.PicOrderCntType == 2 {
//		// noop
//	} else {
//		nazalog.Debugf("not impl yet. sps.PicOrderCntType=%d", sps.PicOrderCntType)
//		return nazaerrors.Wrap(ErrAvc)
//	}
//
//	sps.NumRefFrames, err = br.ReadUeGolomb()
//	if err != nil {
//		return nazaerrors.Wrap(err)
//	}
//	sps.GapsInFrameNumValueAllowedFlag, err = br.ReadBits8(1)
//	if err != nil {
//		return nazaerrors.Wrap(err)
//	}
//	sps.PicWidthInMbsMinusOne, err = br.ReadUeGolomb()
//	if err != nil {
//		return nazaerrors.Wrap(err)
//	}
//	sps.PicHeightInMapUnitsMinusOne, err = br.ReadUeGolomb()
//	if err != nil {
//		return nazaerrors.Wrap(err)
//	}
//	sps.FrameMbsOnlyFlag, err = br.ReadBits8(1)
//	if err != nil {
//		return nazaerrors.Wrap(err)
//	}
//
//	if sps.FrameMbsOnlyFlag == 0 {
//		sps.MbAdaptiveFrameFieldFlag, err = br.ReadBits8(1)
//		if err != nil {
//			return nazaerrors.Wrap(err)
//		}
//	}
//
//	sps.Direct8X8InferenceFlag, err = br.ReadBits8(1)
//	if err != nil {
//		return nazaerrors.Wrap(err)
//	}
//
//	sps.FrameCroppingFlag, err = br.ReadBits8(1)
//	if err != nil {
//		return nazaerrors.Wrap(err)
//	}
//	if sps.FrameCroppingFlag == 1 {
//		sps.FrameCropLeftOffset, err = br.ReadUeGolomb()
//		if err != nil {
//			return nazaerrors.Wrap(err)
//		}
//		sps.FrameCropRightOffset, err = br.ReadUeGolomb()
//		if err != nil {
//			return nazaerrors.Wrap(err)
//		}
//		sps.FrameCropTopOffset, err = br.ReadUeGolomb()
//		if err != nil {
//			return nazaerrors.Wrap(err)
//		}
//		sps.FrameCropBottomOffset, err = br.ReadUeGolomb()
//		if err != nil {
//			return nazaerrors.Wrap(err)
//		}
//	}
//
//	// TODO parse sps vui parameters
//	return nil
//}

//var defaultScaling4 = [][]uint8{
//	{
//		6, 13, 20, 28, 13, 20, 28, 32,
//		20, 28, 32, 37, 28, 32, 37, 42,
//	},
//	{
//		10, 14, 20, 24, 14, 20, 24, 27,
//		20, 24, 27, 30, 24, 27, 30, 34,
//	},
//}
//
//var defaultScaling8 = [][]uint8{
//	{
//		6, 10, 13, 16, 18, 23, 25, 27,
//		10, 11, 16, 18, 23, 25, 27, 29,
//		13, 16, 18, 23, 25, 27, 29, 31,
//		16, 18, 23, 25, 27, 29, 31, 33,
//		18, 23, 25, 27, 29, 31, 33, 36,
//		23, 25, 27, 29, 31, 33, 36, 38,
//		25, 27, 29, 31, 33, 36, 38, 40,
//		27, 29, 31, 33, 36, 38, 40, 42,
//	},
//	{
//		9, 13, 15, 17, 19, 21, 22, 24,
//		13, 13, 17, 19, 21, 22, 24, 25,
//		15, 17, 19, 21, 22, 24, 25, 27,
//		17, 19, 21, 22, 24, 25, 27, 28,
//		19, 21, 22, 24, 25, 27, 28, 30,
//		21, 22, 24, 25, 27, 28, 30, 32,
//		22, 24, 25, 27, 28, 30, 32, 33,
//		24, 25, 27, 28, 30, 32, 33, 35,
//	},
//}
//
//var ffZigzagDirect = []uint8{
//	0, 1, 8, 16, 9, 2, 3, 10,
//	17, 24, 32, 25, 18, 11, 4, 5,
//	12, 19, 26, 33, 40, 48, 41, 34,
//	27, 20, 13, 6, 7, 14, 21, 28,
//	35, 42, 49, 56, 57, 50, 43, 36,
//	29, 22, 15, 23, 30, 37, 44, 51,
//	58, 59, 52, 45, 38, 31, 39, 46,
//	53, 60, 61, 54, 47, 55, 62, 63,
//}
//
//var ffZigzagScan = []uint8{
//	0 + 0*4, 1 + 0*4, 0 + 1*4, 0 + 2*4,
//	1 + 1*4, 2 + 0*4, 3 + 0*4, 2 + 1*4,
//	1 + 2*4, 0 + 3*4, 1 + 3*4, 2 + 2*4,
//	3 + 1*4, 3 + 2*4, 2 + 3*4, 3 + 3*4,
//}
//
//func decodeScalingMatrices(reader *nazabits.BitReader) error {
//	// 6 * 16
//	var spsScalingMatrix4 = [][]uint8{
//		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//	}
//	// 6 * 64
//	var spsScalingMatrix8 = [][]uint8{
//		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//	}
//
//	fallback := [][]uint8{defaultScaling4[0], defaultScaling4[1], defaultScaling8[0], defaultScaling8[1]}
//	decodeScalingList(reader, spsScalingMatrix4[0], 16, defaultScaling4[0], fallback[0])
//	decodeScalingList(reader, spsScalingMatrix4[1], 16, defaultScaling4[0], spsScalingMatrix4[0])
//	decodeScalingList(reader, spsScalingMatrix4[2], 16, defaultScaling4[0], spsScalingMatrix4[1])
//	decodeScalingList(reader, spsScalingMatrix4[3], 16, defaultScaling4[1], fallback[1])
//	decodeScalingList(reader, spsScalingMatrix4[4], 16, defaultScaling4[1], spsScalingMatrix4[3])
//	decodeScalingList(reader, spsScalingMatrix4[4], 16, defaultScaling4[1], spsScalingMatrix4[3])
//
//	decodeScalingList(reader, spsScalingMatrix8[0], 64, defaultScaling8[0], fallback[2])
//	decodeScalingList(reader, spsScalingMatrix8[3], 64, defaultScaling8[1], fallback[3])
//
//	return nil
//}
//
//func decodeScalingList(reader *nazabits.BitReader, factors []uint8, size int, jvtList []uint8, fallbackList []uint8) error {
//	var (
//		i    = 0
//		last = 8
//		next = 8
//		scan []uint8
//	)
//	if size == 16 {
//		scan = ffZigzagScan
//	} else {
//		scan = ffZigzagDirect
//	}
//	flag, err := reader.ReadBit()
//	if err != nil {
//		return err
//	}
//	return nil
//	if flag == 0 {
//		for n := 0; n < size; n++ {
//			factors[n] = fallbackList[n]
//		}
//	} else {
//		for i = 0; i < size; i++ {
//			if next != 0 {
//				v, err := reader.ReadUeGolomb()
//				if err != nil {
//					return err
//				}
//				next = (last + int(v)) & 0xff
//			}
//			if i == 0 && next == 0 {
//				for n := 0; n < size; n++ {
//					factors[n] = jvtList[n]
//				}
//				break
//			}
//			if next != 0 {
//				factors[scan[i]] = uint8(next)
//				last = next
//			} else {
//				factors[scan[i]] = uint8(last)
//			}
//		}
//	}
//	return nil
//}